<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html lang="en">

<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>LCOV - id:000977,sync:fuzzer2,src:001052.lcov_info_final - test/gmock-1.7.0/include/gmock/gmock-generated-matchers.h</title>
  <link rel="stylesheet" type="text/css" href="../../../../gcov.css">
</head>

<body>

  <table width="100%" border=0 cellspacing=0 cellpadding=0>
    <tr><td class="title">LCOV - code coverage report</td></tr>
    <tr><td class="ruler"><img src="../../../../glass.png" width=3 height=3 alt=""></td></tr>

    <tr>
      <td width="100%">
        <table cellpadding=1 border=0 width="100%">
          <tr>
            <td width="10%" class="headerItem">Current view:</td>
            <td width="35%" class="headerValue"><a href="../../../../index.html">top level</a> - <a href="index.html">test/gmock-1.7.0/include/gmock</a> - gmock-generated-matchers.h<span style="font-size: 80%;"> (source / <a href="gmock-generated-matchers.h.func-sort-c.html">functions</a>)</span></td>
            <td width="5%"></td>
            <td width="15%"></td>
            <td width="10%" class="headerCovTableHead">Hit</td>
            <td width="10%" class="headerCovTableHead">Total</td>
            <td width="15%" class="headerCovTableHead">Coverage</td>
          </tr>
          <tr>
            <td class="headerItem">Test:</td>
            <td class="headerValue">id:000977,sync:fuzzer2,src:001052.lcov_info_final</td>
            <td></td>
            <td class="headerItem">Lines:</td>
            <td class="headerCovTableEntry">0</td>
            <td class="headerCovTableEntry">2</td>
            <td class="headerCovTableEntryLo">0.0 %</td>
          </tr>
          <tr>
            <td class="headerItem">Date:</td>
            <td class="headerValue">2016-03-13 10:42:47</td>
            <td></td>
            <td class="headerItem">Functions:</td>
            <td class="headerCovTableEntry">0</td>
            <td class="headerCovTableEntry">1</td>
            <td class="headerCovTableEntryLo">0.0 %</td>
          </tr>
          <tr><td><img src="../../../../glass.png" width=3 height=3 alt=""></td></tr>
        </table>
      </td>
    </tr>

    <tr><td class="ruler"><img src="../../../../glass.png" width=3 height=3 alt=""></td></tr>
  </table>

  <table cellpadding=0 cellspacing=0 border=0>
    <tr>
      <td><br></td>
    </tr>
    <tr>
      <td>
<pre class="sourceHeading">          Line data    Source code</pre>
<pre class="source">
<a name="1"><span class="lineNum">       1 </span>            : // This file was GENERATED by command:</a>
<span class="lineNum">       2 </span>            : //     pump.py gmock-generated-matchers.h.pump
<span class="lineNum">       3 </span>            : // DO NOT EDIT BY HAND!!!
<span class="lineNum">       4 </span>            : 
<span class="lineNum">       5 </span>            : // Copyright 2008, Google Inc.
<span class="lineNum">       6 </span>            : // All rights reserved.
<span class="lineNum">       7 </span>            : //
<span class="lineNum">       8 </span>            : // Redistribution and use in source and binary forms, with or without
<span class="lineNum">       9 </span>            : // modification, are permitted provided that the following conditions are
<span class="lineNum">      10 </span>            : // met:
<span class="lineNum">      11 </span>            : //
<span class="lineNum">      12 </span>            : //     * Redistributions of source code must retain the above copyright
<span class="lineNum">      13 </span>            : // notice, this list of conditions and the following disclaimer.
<span class="lineNum">      14 </span>            : //     * Redistributions in binary form must reproduce the above
<span class="lineNum">      15 </span>            : // copyright notice, this list of conditions and the following disclaimer
<span class="lineNum">      16 </span>            : // in the documentation and/or other materials provided with the
<span class="lineNum">      17 </span>            : // distribution.
<span class="lineNum">      18 </span>            : //     * Neither the name of Google Inc. nor the names of its
<span class="lineNum">      19 </span>            : // contributors may be used to endorse or promote products derived from
<span class="lineNum">      20 </span>            : // this software without specific prior written permission.
<span class="lineNum">      21 </span>            : //
<span class="lineNum">      22 </span>            : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
<span class="lineNum">      23 </span>            : // &quot;AS IS&quot; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
<span class="lineNum">      24 </span>            : // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
<span class="lineNum">      25 </span>            : // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
<span class="lineNum">      26 </span>            : // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
<span class="lineNum">      27 </span>            : // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
<span class="lineNum">      28 </span>            : // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
<span class="lineNum">      29 </span>            : // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
<span class="lineNum">      30 </span>            : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
<span class="lineNum">      31 </span>            : // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<span class="lineNum">      32 </span>            : // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<span class="lineNum">      33 </span>            : 
<span class="lineNum">      34 </span>            : // Google Mock - a framework for writing C++ mock classes.
<span class="lineNum">      35 </span>            : //
<span class="lineNum">      36 </span>            : // This file implements some commonly used variadic matchers.
<span class="lineNum">      37 </span>            : 
<span class="lineNum">      38 </span>            : #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
<span class="lineNum">      39 </span>            : #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
<span class="lineNum">      40 </span>            : 
<span class="lineNum">      41 </span>            : #include &lt;iterator&gt;
<span class="lineNum">      42 </span>            : #include &lt;sstream&gt;
<span class="lineNum">      43 </span>            : #include &lt;string&gt;
<span class="lineNum">      44 </span>            : #include &lt;vector&gt;
<span class="lineNum">      45 </span>            : #include &quot;gmock/gmock-matchers.h&quot;
<span class="lineNum">      46 </span>            : 
<span class="lineNum">      47 </span>            : namespace testing {
<span class="lineNum">      48 </span>            : namespace internal {
<span class="lineNum">      49 </span>            : 
<span class="lineNum">      50 </span>            : // The type of the i-th (0-based) field of Tuple.
<span class="lineNum">      51 </span>            : #define GMOCK_FIELD_TYPE_(Tuple, i) \
<span class="lineNum">      52 </span>            :     typename ::std::tr1::tuple_element&lt;i, Tuple&gt;::type
<span class="lineNum">      53 </span>            : 
<span class="lineNum">      54 </span>            : // TupleFields&lt;Tuple, k0, ..., kn&gt; is for selecting fields from a
<span class="lineNum">      55 </span>            : // tuple of type Tuple.  It has two members:
<span class="lineNum">      56 </span>            : //
<span class="lineNum">      57 </span>            : //   type: a tuple type whose i-th field is the ki-th field of Tuple.
<span class="lineNum">      58 </span>            : //   GetSelectedFields(t): returns fields k0, ..., and kn of t as a tuple.
<span class="lineNum">      59 </span>            : //
<span class="lineNum">      60 </span>            : // For example, in class TupleFields&lt;tuple&lt;bool, char, int&gt;, 2, 0&gt;, we have:
<span class="lineNum">      61 </span>            : //
<span class="lineNum">      62 </span>            : //   type is tuple&lt;int, bool&gt;, and
<span class="lineNum">      63 </span>            : //   GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true).
<span class="lineNum">      64 </span>            : 
<span class="lineNum">      65 </span>            : template &lt;class Tuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
<span class="lineNum">      66 </span>            :     int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
<span class="lineNum">      67 </span>            :     int k9 = -1&gt;
<span class="lineNum">      68 </span>            : class TupleFields;
<span class="lineNum">      69 </span>            : 
<span class="lineNum">      70 </span>            : // This generic version is used when there are 10 selectors.
<span class="lineNum">      71 </span>            : template &lt;class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
<span class="lineNum">      72 </span>            :     int k7, int k8, int k9&gt;
<span class="lineNum">      73 </span>            : class TupleFields {
<span class="lineNum">      74 </span>            :  public:
<span class="lineNum">      75 </span>            :   typedef ::std::tr1::tuple&lt;GMOCK_FIELD_TYPE_(Tuple, k0),
<span class="lineNum">      76 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
<span class="lineNum">      77 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
<span class="lineNum">      78 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
<span class="lineNum">      79 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8),
<span class="lineNum">      80 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k9)&gt; type;
<span class="lineNum">      81 </span>            :   static type GetSelectedFields(const Tuple&amp; t) {
<span class="lineNum">      82 </span>            :     using ::std::tr1::get;
<span class="lineNum">      83 </span>            :     return type(get&lt;k0&gt;(t), get&lt;k1&gt;(t), get&lt;k2&gt;(t), get&lt;k3&gt;(t), get&lt;k4&gt;(t),
<span class="lineNum">      84 </span>            :         get&lt;k5&gt;(t), get&lt;k6&gt;(t), get&lt;k7&gt;(t), get&lt;k8&gt;(t), get&lt;k9&gt;(t));
<span class="lineNum">      85 </span>            :   }
<span class="lineNum">      86 </span>            : };
<span class="lineNum">      87 </span>            : 
<span class="lineNum">      88 </span>            : // The following specialization is used for 0 ~ 9 selectors.
<span class="lineNum">      89 </span>            : 
<span class="lineNum">      90 </span>            : template &lt;class Tuple&gt;
<span class="lineNum">      91 </span>            : class TupleFields&lt;Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1&gt; {
<span class="lineNum">      92 </span>            :  public:
<span class="lineNum">      93 </span>            :   typedef ::std::tr1::tuple&lt;&gt; type;
<span class="lineNum">      94 </span>            :   static type GetSelectedFields(const Tuple&amp; /* t */) {
<span class="lineNum">      95 </span>            :     using ::std::tr1::get;
<span class="lineNum">      96 </span>            :     return type();
<span class="lineNum">      97 </span>            :   }
<span class="lineNum">      98 </span>            : };
<span class="lineNum">      99 </span>            : 
<span class="lineNum">     100 </span>            : template &lt;class Tuple, int k0&gt;
<span class="lineNum">     101 </span>            : class TupleFields&lt;Tuple, k0, -1, -1, -1, -1, -1, -1, -1, -1, -1&gt; {
<span class="lineNum">     102 </span>            :  public:
<span class="lineNum">     103 </span>            :   typedef ::std::tr1::tuple&lt;GMOCK_FIELD_TYPE_(Tuple, k0)&gt; type;
<span class="lineNum">     104 </span>            :   static type GetSelectedFields(const Tuple&amp; t) {
<span class="lineNum">     105 </span>            :     using ::std::tr1::get;
<span class="lineNum">     106 </span>            :     return type(get&lt;k0&gt;(t));
<span class="lineNum">     107 </span>            :   }
<span class="lineNum">     108 </span>            : };
<span class="lineNum">     109 </span>            : 
<span class="lineNum">     110 </span>            : template &lt;class Tuple, int k0, int k1&gt;
<span class="lineNum">     111 </span>            : class TupleFields&lt;Tuple, k0, k1, -1, -1, -1, -1, -1, -1, -1, -1&gt; {
<span class="lineNum">     112 </span>            :  public:
<span class="lineNum">     113 </span>            :   typedef ::std::tr1::tuple&lt;GMOCK_FIELD_TYPE_(Tuple, k0),
<span class="lineNum">     114 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k1)&gt; type;
<span class="lineNum">     115 </span>            :   static type GetSelectedFields(const Tuple&amp; t) {
<span class="lineNum">     116 </span>            :     using ::std::tr1::get;
<span class="lineNum">     117 </span>            :     return type(get&lt;k0&gt;(t), get&lt;k1&gt;(t));
<span class="lineNum">     118 </span>            :   }
<span class="lineNum">     119 </span>            : };
<span class="lineNum">     120 </span>            : 
<span class="lineNum">     121 </span>            : template &lt;class Tuple, int k0, int k1, int k2&gt;
<span class="lineNum">     122 </span>            : class TupleFields&lt;Tuple, k0, k1, k2, -1, -1, -1, -1, -1, -1, -1&gt; {
<span class="lineNum">     123 </span>            :  public:
<span class="lineNum">     124 </span>            :   typedef ::std::tr1::tuple&lt;GMOCK_FIELD_TYPE_(Tuple, k0),
<span class="lineNum">     125 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2)&gt; type;
<span class="lineNum">     126 </span>            :   static type GetSelectedFields(const Tuple&amp; t) {
<span class="lineNum">     127 </span>            :     using ::std::tr1::get;
<span class="lineNum">     128 </span>            :     return type(get&lt;k0&gt;(t), get&lt;k1&gt;(t), get&lt;k2&gt;(t));
<span class="lineNum">     129 </span>            :   }
<span class="lineNum">     130 </span>            : };
<span class="lineNum">     131 </span>            : 
<span class="lineNum">     132 </span>            : template &lt;class Tuple, int k0, int k1, int k2, int k3&gt;
<span class="lineNum">     133 </span>            : class TupleFields&lt;Tuple, k0, k1, k2, k3, -1, -1, -1, -1, -1, -1&gt; {
<span class="lineNum">     134 </span>            :  public:
<span class="lineNum">     135 </span>            :   typedef ::std::tr1::tuple&lt;GMOCK_FIELD_TYPE_(Tuple, k0),
<span class="lineNum">     136 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
<span class="lineNum">     137 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k3)&gt; type;
<span class="lineNum">     138 </span>            :   static type GetSelectedFields(const Tuple&amp; t) {
<span class="lineNum">     139 </span>            :     using ::std::tr1::get;
<span class="lineNum">     140 </span>            :     return type(get&lt;k0&gt;(t), get&lt;k1&gt;(t), get&lt;k2&gt;(t), get&lt;k3&gt;(t));
<span class="lineNum">     141 </span>            :   }
<span class="lineNum">     142 </span>            : };
<span class="lineNum">     143 </span>            : 
<span class="lineNum">     144 </span>            : template &lt;class Tuple, int k0, int k1, int k2, int k3, int k4&gt;
<span class="lineNum">     145 </span>            : class TupleFields&lt;Tuple, k0, k1, k2, k3, k4, -1, -1, -1, -1, -1&gt; {
<span class="lineNum">     146 </span>            :  public:
<span class="lineNum">     147 </span>            :   typedef ::std::tr1::tuple&lt;GMOCK_FIELD_TYPE_(Tuple, k0),
<span class="lineNum">     148 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
<span class="lineNum">     149 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4)&gt; type;
<span class="lineNum">     150 </span>            :   static type GetSelectedFields(const Tuple&amp; t) {
<span class="lineNum">     151 </span>            :     using ::std::tr1::get;
<span class="lineNum">     152 </span>            :     return type(get&lt;k0&gt;(t), get&lt;k1&gt;(t), get&lt;k2&gt;(t), get&lt;k3&gt;(t), get&lt;k4&gt;(t));
<span class="lineNum">     153 </span>            :   }
<span class="lineNum">     154 </span>            : };
<span class="lineNum">     155 </span>            : 
<span class="lineNum">     156 </span>            : template &lt;class Tuple, int k0, int k1, int k2, int k3, int k4, int k5&gt;
<span class="lineNum">     157 </span>            : class TupleFields&lt;Tuple, k0, k1, k2, k3, k4, k5, -1, -1, -1, -1&gt; {
<span class="lineNum">     158 </span>            :  public:
<span class="lineNum">     159 </span>            :   typedef ::std::tr1::tuple&lt;GMOCK_FIELD_TYPE_(Tuple, k0),
<span class="lineNum">     160 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
<span class="lineNum">     161 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
<span class="lineNum">     162 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k5)&gt; type;
<span class="lineNum">     163 </span>            :   static type GetSelectedFields(const Tuple&amp; t) {
<span class="lineNum">     164 </span>            :     using ::std::tr1::get;
<span class="lineNum">     165 </span>            :     return type(get&lt;k0&gt;(t), get&lt;k1&gt;(t), get&lt;k2&gt;(t), get&lt;k3&gt;(t), get&lt;k4&gt;(t),
<span class="lineNum">     166 </span>            :         get&lt;k5&gt;(t));
<span class="lineNum">     167 </span>            :   }
<span class="lineNum">     168 </span>            : };
<span class="lineNum">     169 </span>            : 
<span class="lineNum">     170 </span>            : template &lt;class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6&gt;
<span class="lineNum">     171 </span>            : class TupleFields&lt;Tuple, k0, k1, k2, k3, k4, k5, k6, -1, -1, -1&gt; {
<span class="lineNum">     172 </span>            :  public:
<span class="lineNum">     173 </span>            :   typedef ::std::tr1::tuple&lt;GMOCK_FIELD_TYPE_(Tuple, k0),
<span class="lineNum">     174 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
<span class="lineNum">     175 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
<span class="lineNum">     176 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6)&gt; type;
<span class="lineNum">     177 </span>            :   static type GetSelectedFields(const Tuple&amp; t) {
<span class="lineNum">     178 </span>            :     using ::std::tr1::get;
<span class="lineNum">     179 </span>            :     return type(get&lt;k0&gt;(t), get&lt;k1&gt;(t), get&lt;k2&gt;(t), get&lt;k3&gt;(t), get&lt;k4&gt;(t),
<span class="lineNum">     180 </span>            :         get&lt;k5&gt;(t), get&lt;k6&gt;(t));
<span class="lineNum">     181 </span>            :   }
<span class="lineNum">     182 </span>            : };
<span class="lineNum">     183 </span>            : 
<span class="lineNum">     184 </span>            : template &lt;class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
<span class="lineNum">     185 </span>            :     int k7&gt;
<span class="lineNum">     186 </span>            : class TupleFields&lt;Tuple, k0, k1, k2, k3, k4, k5, k6, k7, -1, -1&gt; {
<span class="lineNum">     187 </span>            :  public:
<span class="lineNum">     188 </span>            :   typedef ::std::tr1::tuple&lt;GMOCK_FIELD_TYPE_(Tuple, k0),
<span class="lineNum">     189 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
<span class="lineNum">     190 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
<span class="lineNum">     191 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
<span class="lineNum">     192 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k7)&gt; type;
<span class="lineNum">     193 </span>            :   static type GetSelectedFields(const Tuple&amp; t) {
<span class="lineNum">     194 </span>            :     using ::std::tr1::get;
<span class="lineNum">     195 </span>            :     return type(get&lt;k0&gt;(t), get&lt;k1&gt;(t), get&lt;k2&gt;(t), get&lt;k3&gt;(t), get&lt;k4&gt;(t),
<span class="lineNum">     196 </span>            :         get&lt;k5&gt;(t), get&lt;k6&gt;(t), get&lt;k7&gt;(t));
<span class="lineNum">     197 </span>            :   }
<span class="lineNum">     198 </span>            : };
<span class="lineNum">     199 </span>            : 
<span class="lineNum">     200 </span>            : template &lt;class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
<span class="lineNum">     201 </span>            :     int k7, int k8&gt;
<span class="lineNum">     202 </span>            : class TupleFields&lt;Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, -1&gt; {
<span class="lineNum">     203 </span>            :  public:
<span class="lineNum">     204 </span>            :   typedef ::std::tr1::tuple&lt;GMOCK_FIELD_TYPE_(Tuple, k0),
<span class="lineNum">     205 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
<span class="lineNum">     206 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
<span class="lineNum">     207 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
<span class="lineNum">     208 </span>            :       GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8)&gt; type;
<span class="lineNum">     209 </span>            :   static type GetSelectedFields(const Tuple&amp; t) {
<span class="lineNum">     210 </span>            :     using ::std::tr1::get;
<span class="lineNum">     211 </span>            :     return type(get&lt;k0&gt;(t), get&lt;k1&gt;(t), get&lt;k2&gt;(t), get&lt;k3&gt;(t), get&lt;k4&gt;(t),
<span class="lineNum">     212 </span>            :         get&lt;k5&gt;(t), get&lt;k6&gt;(t), get&lt;k7&gt;(t), get&lt;k8&gt;(t));
<span class="lineNum">     213 </span>            :   }
<span class="lineNum">     214 </span>            : };
<span class="lineNum">     215 </span>            : 
<span class="lineNum">     216 </span>            : #undef GMOCK_FIELD_TYPE_
<span class="lineNum">     217 </span>            : 
<span class="lineNum">     218 </span>            : // Implements the Args() matcher.
<span class="lineNum">     219 </span>            : template &lt;class ArgsTuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
<span class="lineNum">     220 </span>            :     int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
<span class="lineNum">     221 </span>            :     int k9 = -1&gt;
<span class="lineNum">     222 </span>            : class ArgsMatcherImpl : public MatcherInterface&lt;ArgsTuple&gt; {
<span class="lineNum">     223 </span>            :  public:
<span class="lineNum">     224 </span>            :   // ArgsTuple may have top-level const or reference modifiers.
<span class="lineNum">     225 </span>            :   typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;
<span class="lineNum">     226 </span>            :   typedef typename internal::TupleFields&lt;RawArgsTuple, k0, k1, k2, k3, k4, k5,
<span class="lineNum">     227 </span>            :       k6, k7, k8, k9&gt;::type SelectedArgs;
<span class="lineNum">     228 </span>            :   typedef Matcher&lt;const SelectedArgs&amp;&gt; MonomorphicInnerMatcher;
<span class="lineNum">     229 </span>            : 
<span class="lineNum">     230 </span>            :   template &lt;typename InnerMatcher&gt;
<span class="lineNum">     231 </span>            :   explicit ArgsMatcherImpl(const InnerMatcher&amp; inner_matcher)
<span class="lineNum">     232 </span>            :       : inner_matcher_(SafeMatcherCast&lt;const SelectedArgs&amp;&gt;(inner_matcher)) {}
<span class="lineNum">     233 </span>            : 
<span class="lineNum">     234 </span>            :   virtual bool MatchAndExplain(ArgsTuple args,
<span class="lineNum">     235 </span>            :                                MatchResultListener* listener) const {
<span class="lineNum">     236 </span>            :     const SelectedArgs&amp; selected_args = GetSelectedArgs(args);
<span class="lineNum">     237 </span>            :     if (!listener-&gt;IsInterested())
<span class="lineNum">     238 </span>            :       return inner_matcher_.Matches(selected_args);
<span class="lineNum">     239 </span>            : 
<span class="lineNum">     240 </span>            :     PrintIndices(listener-&gt;stream());
<span class="lineNum">     241 </span>            :     *listener &lt;&lt; &quot;are &quot; &lt;&lt; PrintToString(selected_args);
<span class="lineNum">     242 </span>            : 
<span class="lineNum">     243 </span>            :     StringMatchResultListener inner_listener;
<span class="lineNum">     244 </span>            :     const bool match = inner_matcher_.MatchAndExplain(selected_args,
<span class="lineNum">     245 </span>            :                                                       &amp;inner_listener);
<span class="lineNum">     246 </span>            :     PrintIfNotEmpty(inner_listener.str(), listener-&gt;stream());
<span class="lineNum">     247 </span>            :     return match;
<span class="lineNum">     248 </span>            :   }
<span class="lineNum">     249 </span>            : 
<span class="lineNum">     250 </span>            :   virtual void DescribeTo(::std::ostream* os) const {
<span class="lineNum">     251 </span>            :     *os &lt;&lt; &quot;are a tuple &quot;;
<span class="lineNum">     252 </span>            :     PrintIndices(os);
<span class="lineNum">     253 </span>            :     inner_matcher_.DescribeTo(os);
<span class="lineNum">     254 </span>            :   }
<span class="lineNum">     255 </span>            : 
<span class="lineNum">     256 </span>            :   virtual void DescribeNegationTo(::std::ostream* os) const {
<span class="lineNum">     257 </span>            :     *os &lt;&lt; &quot;are a tuple &quot;;
<span class="lineNum">     258 </span>            :     PrintIndices(os);
<span class="lineNum">     259 </span>            :     inner_matcher_.DescribeNegationTo(os);
<span class="lineNum">     260 </span>            :   }
<span class="lineNum">     261 </span>            : 
<span class="lineNum">     262 </span>            :  private:
<span class="lineNum">     263 </span>            :   static SelectedArgs GetSelectedArgs(ArgsTuple args) {
<span class="lineNum">     264 </span>            :     return TupleFields&lt;RawArgsTuple, k0, k1, k2, k3, k4, k5, k6, k7, k8,
<span class="lineNum">     265 </span>            :         k9&gt;::GetSelectedFields(args);
<span class="lineNum">     266 </span>            :   }
<span class="lineNum">     267 </span>            : 
<span class="lineNum">     268 </span>            :   // Prints the indices of the selected fields.
<span class="lineNum">     269 </span>            :   static void PrintIndices(::std::ostream* os) {
<span class="lineNum">     270 </span>            :     *os &lt;&lt; &quot;whose fields (&quot;;
<span class="lineNum">     271 </span>            :     const int indices[10] = { k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 };
<span class="lineNum">     272 </span>            :     for (int i = 0; i &lt; 10; i++) {
<span class="lineNum">     273 </span>            :       if (indices[i] &lt; 0)
<span class="lineNum">     274 </span>            :         break;
<span class="lineNum">     275 </span>            : 
<span class="lineNum">     276 </span>            :       if (i &gt;= 1)
<span class="lineNum">     277 </span>            :         *os &lt;&lt; &quot;, &quot;;
<span class="lineNum">     278 </span>            : 
<span class="lineNum">     279 </span>            :       *os &lt;&lt; &quot;#&quot; &lt;&lt; indices[i];
<span class="lineNum">     280 </span>            :     }
<span class="lineNum">     281 </span>            :     *os &lt;&lt; &quot;) &quot;;
<span class="lineNum">     282 </span>            :   }
<span class="lineNum">     283 </span>            : 
<span class="lineNum">     284 </span>            :   const MonomorphicInnerMatcher inner_matcher_;
<span class="lineNum">     285 </span>            : 
<span class="lineNum">     286 </span>            :   GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
<span class="lineNum">     287 </span>            : };
<span class="lineNum">     288 </span>            : 
<span class="lineNum">     289 </span>            : template &lt;class InnerMatcher, int k0 = -1, int k1 = -1, int k2 = -1,
<span class="lineNum">     290 </span>            :     int k3 = -1, int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1,
<span class="lineNum">     291 </span>            :     int k8 = -1, int k9 = -1&gt;
<span class="lineNum">     292 </span>            : class ArgsMatcher {
<span class="lineNum">     293 </span>            :  public:
<span class="lineNum">     294 </span>            :   explicit ArgsMatcher(const InnerMatcher&amp; inner_matcher)
<span class="lineNum">     295 </span>            :       : inner_matcher_(inner_matcher) {}
<span class="lineNum">     296 </span>            : 
<span class="lineNum">     297 </span>            :   template &lt;typename ArgsTuple&gt;
<span class="lineNum">     298 </span>            :   operator Matcher&lt;ArgsTuple&gt;() const {
<span class="lineNum">     299 </span>            :     return MakeMatcher(new ArgsMatcherImpl&lt;ArgsTuple, k0, k1, k2, k3, k4, k5,
<span class="lineNum">     300 </span>            :         k6, k7, k8, k9&gt;(inner_matcher_));
<span class="lineNum">     301 </span>            :   }
<span class="lineNum">     302 </span>            : 
<span class="lineNum">     303 </span>            :  private:
<span class="lineNum">     304 </span>            :   const InnerMatcher inner_matcher_;
<span class="lineNum">     305 </span>            : 
<span class="lineNum">     306 </span>            :   GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
<span class="lineNum">     307 </span>            : };
<span class="lineNum">     308 </span>            : 
<span class="lineNum">     309 </span>            : // A set of metafunctions for computing the result type of AllOf.
<span class="lineNum">     310 </span>            : // AllOf(m1, ..., mN) returns
<span class="lineNum">     311 </span>            : // AllOfResultN&lt;decltype(m1), ..., decltype(mN)&gt;::type.
<span class="lineNum">     312 </span>            : 
<span class="lineNum">     313 </span>            : // Although AllOf isn't defined for one argument, AllOfResult1 is defined
<span class="lineNum">     314 </span>            : // to simplify the implementation.
<span class="lineNum">     315 </span>            : template &lt;typename M1&gt;
<span class="lineNum">     316 </span>            : struct AllOfResult1 {
<span class="lineNum">     317 </span>            :   typedef M1 type;
<span class="lineNum">     318 </span>            : };
<span class="lineNum">     319 </span>            : 
<span class="lineNum">     320 </span>            : template &lt;typename M1, typename M2&gt;
<span class="lineNum">     321 </span>            : struct AllOfResult2 {
<span class="lineNum">     322 </span>            :   typedef BothOfMatcher&lt;
<span class="lineNum">     323 </span>            :       typename AllOfResult1&lt;M1&gt;::type,
<span class="lineNum">     324 </span>            :       typename AllOfResult1&lt;M2&gt;::type
<span class="lineNum">     325 </span>            :   &gt; type;
<span class="lineNum">     326 </span>            : };
<span class="lineNum">     327 </span>            : 
<span class="lineNum">     328 </span>            : template &lt;typename M1, typename M2, typename M3&gt;
<span class="lineNum">     329 </span>            : struct AllOfResult3 {
<span class="lineNum">     330 </span>            :   typedef BothOfMatcher&lt;
<span class="lineNum">     331 </span>            :       typename AllOfResult1&lt;M1&gt;::type,
<span class="lineNum">     332 </span>            :       typename AllOfResult2&lt;M2, M3&gt;::type
<span class="lineNum">     333 </span>            :   &gt; type;
<span class="lineNum">     334 </span>            : };
<span class="lineNum">     335 </span>            : 
<span class="lineNum">     336 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4&gt;
<span class="lineNum">     337 </span>            : struct AllOfResult4 {
<span class="lineNum">     338 </span>            :   typedef BothOfMatcher&lt;
<span class="lineNum">     339 </span>            :       typename AllOfResult2&lt;M1, M2&gt;::type,
<span class="lineNum">     340 </span>            :       typename AllOfResult2&lt;M3, M4&gt;::type
<span class="lineNum">     341 </span>            :   &gt; type;
<span class="lineNum">     342 </span>            : };
<span class="lineNum">     343 </span>            : 
<span class="lineNum">     344 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5&gt;
<span class="lineNum">     345 </span>            : struct AllOfResult5 {
<span class="lineNum">     346 </span>            :   typedef BothOfMatcher&lt;
<span class="lineNum">     347 </span>            :       typename AllOfResult2&lt;M1, M2&gt;::type,
<span class="lineNum">     348 </span>            :       typename AllOfResult3&lt;M3, M4, M5&gt;::type
<span class="lineNum">     349 </span>            :   &gt; type;
<span class="lineNum">     350 </span>            : };
<span class="lineNum">     351 </span>            : 
<span class="lineNum">     352 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">     353 </span>            :     typename M6&gt;
<span class="lineNum">     354 </span>            : struct AllOfResult6 {
<span class="lineNum">     355 </span>            :   typedef BothOfMatcher&lt;
<span class="lineNum">     356 </span>            :       typename AllOfResult3&lt;M1, M2, M3&gt;::type,
<span class="lineNum">     357 </span>            :       typename AllOfResult3&lt;M4, M5, M6&gt;::type
<span class="lineNum">     358 </span>            :   &gt; type;
<span class="lineNum">     359 </span>            : };
<span class="lineNum">     360 </span>            : 
<span class="lineNum">     361 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">     362 </span>            :     typename M6, typename M7&gt;
<span class="lineNum">     363 </span>            : struct AllOfResult7 {
<span class="lineNum">     364 </span>            :   typedef BothOfMatcher&lt;
<span class="lineNum">     365 </span>            :       typename AllOfResult3&lt;M1, M2, M3&gt;::type,
<span class="lineNum">     366 </span>            :       typename AllOfResult4&lt;M4, M5, M6, M7&gt;::type
<span class="lineNum">     367 </span>            :   &gt; type;
<span class="lineNum">     368 </span>            : };
<span class="lineNum">     369 </span>            : 
<span class="lineNum">     370 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">     371 </span>            :     typename M6, typename M7, typename M8&gt;
<span class="lineNum">     372 </span>            : struct AllOfResult8 {
<span class="lineNum">     373 </span>            :   typedef BothOfMatcher&lt;
<span class="lineNum">     374 </span>            :       typename AllOfResult4&lt;M1, M2, M3, M4&gt;::type,
<span class="lineNum">     375 </span>            :       typename AllOfResult4&lt;M5, M6, M7, M8&gt;::type
<span class="lineNum">     376 </span>            :   &gt; type;
<span class="lineNum">     377 </span>            : };
<span class="lineNum">     378 </span>            : 
<span class="lineNum">     379 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">     380 </span>            :     typename M6, typename M7, typename M8, typename M9&gt;
<span class="lineNum">     381 </span>            : struct AllOfResult9 {
<span class="lineNum">     382 </span>            :   typedef BothOfMatcher&lt;
<span class="lineNum">     383 </span>            :       typename AllOfResult4&lt;M1, M2, M3, M4&gt;::type,
<span class="lineNum">     384 </span>            :       typename AllOfResult5&lt;M5, M6, M7, M8, M9&gt;::type
<span class="lineNum">     385 </span>            :   &gt; type;
<span class="lineNum">     386 </span>            : };
<span class="lineNum">     387 </span>            : 
<span class="lineNum">     388 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">     389 </span>            :     typename M6, typename M7, typename M8, typename M9, typename M10&gt;
<span class="lineNum">     390 </span>            : struct AllOfResult10 {
<span class="lineNum">     391 </span>            :   typedef BothOfMatcher&lt;
<span class="lineNum">     392 </span>            :       typename AllOfResult5&lt;M1, M2, M3, M4, M5&gt;::type,
<span class="lineNum">     393 </span>            :       typename AllOfResult5&lt;M6, M7, M8, M9, M10&gt;::type
<span class="lineNum">     394 </span>            :   &gt; type;
<span class="lineNum">     395 </span>            : };
<span class="lineNum">     396 </span>            : 
<span class="lineNum">     397 </span>            : // A set of metafunctions for computing the result type of AnyOf.
<span class="lineNum">     398 </span>            : // AnyOf(m1, ..., mN) returns
<span class="lineNum">     399 </span>            : // AnyOfResultN&lt;decltype(m1), ..., decltype(mN)&gt;::type.
<span class="lineNum">     400 </span>            : 
<span class="lineNum">     401 </span>            : // Although AnyOf isn't defined for one argument, AnyOfResult1 is defined
<span class="lineNum">     402 </span>            : // to simplify the implementation.
<span class="lineNum">     403 </span>            : template &lt;typename M1&gt;
<span class="lineNum">     404 </span>            : struct AnyOfResult1 {
<span class="lineNum">     405 </span>            :   typedef M1 type;
<span class="lineNum">     406 </span>            : };
<span class="lineNum">     407 </span>            : 
<span class="lineNum">     408 </span>            : template &lt;typename M1, typename M2&gt;
<span class="lineNum">     409 </span>            : struct AnyOfResult2 {
<span class="lineNum">     410 </span>            :   typedef EitherOfMatcher&lt;
<span class="lineNum">     411 </span>            :       typename AnyOfResult1&lt;M1&gt;::type,
<span class="lineNum">     412 </span>            :       typename AnyOfResult1&lt;M2&gt;::type
<span class="lineNum">     413 </span>            :   &gt; type;
<span class="lineNum">     414 </span>            : };
<span class="lineNum">     415 </span>            : 
<span class="lineNum">     416 </span>            : template &lt;typename M1, typename M2, typename M3&gt;
<span class="lineNum">     417 </span>            : struct AnyOfResult3 {
<span class="lineNum">     418 </span>            :   typedef EitherOfMatcher&lt;
<span class="lineNum">     419 </span>            :       typename AnyOfResult1&lt;M1&gt;::type,
<span class="lineNum">     420 </span>            :       typename AnyOfResult2&lt;M2, M3&gt;::type
<span class="lineNum">     421 </span>            :   &gt; type;
<span class="lineNum">     422 </span>            : };
<span class="lineNum">     423 </span>            : 
<span class="lineNum">     424 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4&gt;
<span class="lineNum">     425 </span>            : struct AnyOfResult4 {
<span class="lineNum">     426 </span>            :   typedef EitherOfMatcher&lt;
<span class="lineNum">     427 </span>            :       typename AnyOfResult2&lt;M1, M2&gt;::type,
<span class="lineNum">     428 </span>            :       typename AnyOfResult2&lt;M3, M4&gt;::type
<span class="lineNum">     429 </span>            :   &gt; type;
<span class="lineNum">     430 </span>            : };
<span class="lineNum">     431 </span>            : 
<span class="lineNum">     432 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5&gt;
<span class="lineNum">     433 </span>            : struct AnyOfResult5 {
<span class="lineNum">     434 </span>            :   typedef EitherOfMatcher&lt;
<span class="lineNum">     435 </span>            :       typename AnyOfResult2&lt;M1, M2&gt;::type,
<span class="lineNum">     436 </span>            :       typename AnyOfResult3&lt;M3, M4, M5&gt;::type
<span class="lineNum">     437 </span>            :   &gt; type;
<span class="lineNum">     438 </span>            : };
<span class="lineNum">     439 </span>            : 
<span class="lineNum">     440 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">     441 </span>            :     typename M6&gt;
<span class="lineNum">     442 </span>            : struct AnyOfResult6 {
<span class="lineNum">     443 </span>            :   typedef EitherOfMatcher&lt;
<span class="lineNum">     444 </span>            :       typename AnyOfResult3&lt;M1, M2, M3&gt;::type,
<span class="lineNum">     445 </span>            :       typename AnyOfResult3&lt;M4, M5, M6&gt;::type
<span class="lineNum">     446 </span>            :   &gt; type;
<span class="lineNum">     447 </span>            : };
<span class="lineNum">     448 </span>            : 
<span class="lineNum">     449 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">     450 </span>            :     typename M6, typename M7&gt;
<span class="lineNum">     451 </span>            : struct AnyOfResult7 {
<span class="lineNum">     452 </span>            :   typedef EitherOfMatcher&lt;
<span class="lineNum">     453 </span>            :       typename AnyOfResult3&lt;M1, M2, M3&gt;::type,
<span class="lineNum">     454 </span>            :       typename AnyOfResult4&lt;M4, M5, M6, M7&gt;::type
<span class="lineNum">     455 </span>            :   &gt; type;
<span class="lineNum">     456 </span>            : };
<span class="lineNum">     457 </span>            : 
<span class="lineNum">     458 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">     459 </span>            :     typename M6, typename M7, typename M8&gt;
<span class="lineNum">     460 </span>            : struct AnyOfResult8 {
<span class="lineNum">     461 </span>            :   typedef EitherOfMatcher&lt;
<span class="lineNum">     462 </span>            :       typename AnyOfResult4&lt;M1, M2, M3, M4&gt;::type,
<span class="lineNum">     463 </span>            :       typename AnyOfResult4&lt;M5, M6, M7, M8&gt;::type
<span class="lineNum">     464 </span>            :   &gt; type;
<span class="lineNum">     465 </span>            : };
<span class="lineNum">     466 </span>            : 
<span class="lineNum">     467 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">     468 </span>            :     typename M6, typename M7, typename M8, typename M9&gt;
<span class="lineNum">     469 </span>            : struct AnyOfResult9 {
<span class="lineNum">     470 </span>            :   typedef EitherOfMatcher&lt;
<span class="lineNum">     471 </span>            :       typename AnyOfResult4&lt;M1, M2, M3, M4&gt;::type,
<span class="lineNum">     472 </span>            :       typename AnyOfResult5&lt;M5, M6, M7, M8, M9&gt;::type
<span class="lineNum">     473 </span>            :   &gt; type;
<span class="lineNum">     474 </span>            : };
<span class="lineNum">     475 </span>            : 
<span class="lineNum">     476 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">     477 </span>            :     typename M6, typename M7, typename M8, typename M9, typename M10&gt;
<span class="lineNum">     478 </span>            : struct AnyOfResult10 {
<span class="lineNum">     479 </span>            :   typedef EitherOfMatcher&lt;
<span class="lineNum">     480 </span>            :       typename AnyOfResult5&lt;M1, M2, M3, M4, M5&gt;::type,
<span class="lineNum">     481 </span>            :       typename AnyOfResult5&lt;M6, M7, M8, M9, M10&gt;::type
<span class="lineNum">     482 </span>            :   &gt; type;
<span class="lineNum">     483 </span>            : };
<span class="lineNum">     484 </span>            : 
<span class="lineNum">     485 </span>            : }  // namespace internal
<span class="lineNum">     486 </span>            : 
<span class="lineNum">     487 </span>            : // Args&lt;N1, N2, ..., Nk&gt;(a_matcher) matches a tuple if the selected
<span class="lineNum">     488 </span>            : // fields of it matches a_matcher.  C++ doesn't support default
<span class="lineNum">     489 </span>            : // arguments for function templates, so we have to overload it.
<span class="lineNum">     490 </span>            : template &lt;typename InnerMatcher&gt;
<span class="lineNum">     491 </span>            : inline internal::ArgsMatcher&lt;InnerMatcher&gt;
<span class="lineNum">     492 </span>            : Args(const InnerMatcher&amp; matcher) {
<span class="lineNum">     493 </span>            :   return internal::ArgsMatcher&lt;InnerMatcher&gt;(matcher);
<span class="lineNum">     494 </span>            : }
<span class="lineNum">     495 </span>            : 
<span class="lineNum">     496 </span>            : template &lt;int k1, typename InnerMatcher&gt;
<span class="lineNum">     497 </span>            : inline internal::ArgsMatcher&lt;InnerMatcher, k1&gt;
<span class="lineNum">     498 </span>            : Args(const InnerMatcher&amp; matcher) {
<span class="lineNum">     499 </span>            :   return internal::ArgsMatcher&lt;InnerMatcher, k1&gt;(matcher);
<span class="lineNum">     500 </span>            : }
<span class="lineNum">     501 </span>            : 
<span class="lineNum">     502 </span>            : template &lt;int k1, int k2, typename InnerMatcher&gt;
<span class="lineNum">     503 </span>            : inline internal::ArgsMatcher&lt;InnerMatcher, k1, k2&gt;
<span class="lineNum">     504 </span>            : Args(const InnerMatcher&amp; matcher) {
<span class="lineNum">     505 </span>            :   return internal::ArgsMatcher&lt;InnerMatcher, k1, k2&gt;(matcher);
<span class="lineNum">     506 </span>            : }
<span class="lineNum">     507 </span>            : 
<span class="lineNum">     508 </span>            : template &lt;int k1, int k2, int k3, typename InnerMatcher&gt;
<span class="lineNum">     509 </span>            : inline internal::ArgsMatcher&lt;InnerMatcher, k1, k2, k3&gt;
<span class="lineNum">     510 </span>            : Args(const InnerMatcher&amp; matcher) {
<span class="lineNum">     511 </span>            :   return internal::ArgsMatcher&lt;InnerMatcher, k1, k2, k3&gt;(matcher);
<span class="lineNum">     512 </span>            : }
<span class="lineNum">     513 </span>            : 
<span class="lineNum">     514 </span>            : template &lt;int k1, int k2, int k3, int k4, typename InnerMatcher&gt;
<span class="lineNum">     515 </span>            : inline internal::ArgsMatcher&lt;InnerMatcher, k1, k2, k3, k4&gt;
<span class="lineNum">     516 </span>            : Args(const InnerMatcher&amp; matcher) {
<span class="lineNum">     517 </span>            :   return internal::ArgsMatcher&lt;InnerMatcher, k1, k2, k3, k4&gt;(matcher);
<span class="lineNum">     518 </span>            : }
<span class="lineNum">     519 </span>            : 
<span class="lineNum">     520 </span>            : template &lt;int k1, int k2, int k3, int k4, int k5, typename InnerMatcher&gt;
<span class="lineNum">     521 </span>            : inline internal::ArgsMatcher&lt;InnerMatcher, k1, k2, k3, k4, k5&gt;
<span class="lineNum">     522 </span>            : Args(const InnerMatcher&amp; matcher) {
<span class="lineNum">     523 </span>            :   return internal::ArgsMatcher&lt;InnerMatcher, k1, k2, k3, k4, k5&gt;(matcher);
<span class="lineNum">     524 </span>            : }
<span class="lineNum">     525 </span>            : 
<span class="lineNum">     526 </span>            : template &lt;int k1, int k2, int k3, int k4, int k5, int k6, typename InnerMatcher&gt;
<span class="lineNum">     527 </span>            : inline internal::ArgsMatcher&lt;InnerMatcher, k1, k2, k3, k4, k5, k6&gt;
<span class="lineNum">     528 </span>            : Args(const InnerMatcher&amp; matcher) {
<span class="lineNum">     529 </span>            :   return internal::ArgsMatcher&lt;InnerMatcher, k1, k2, k3, k4, k5, k6&gt;(matcher);
<span class="lineNum">     530 </span>            : }
<span class="lineNum">     531 </span>            : 
<span class="lineNum">     532 </span>            : template &lt;int k1, int k2, int k3, int k4, int k5, int k6, int k7,
<span class="lineNum">     533 </span>            :     typename InnerMatcher&gt;
<span class="lineNum">     534 </span>            : inline internal::ArgsMatcher&lt;InnerMatcher, k1, k2, k3, k4, k5, k6, k7&gt;
<span class="lineNum">     535 </span>            : Args(const InnerMatcher&amp; matcher) {
<span class="lineNum">     536 </span>            :   return internal::ArgsMatcher&lt;InnerMatcher, k1, k2, k3, k4, k5, k6,
<span class="lineNum">     537 </span>            :       k7&gt;(matcher);
<span class="lineNum">     538 </span>            : }
<span class="lineNum">     539 </span>            : 
<span class="lineNum">     540 </span>            : template &lt;int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
<span class="lineNum">     541 </span>            :     typename InnerMatcher&gt;
<span class="lineNum">     542 </span>            : inline internal::ArgsMatcher&lt;InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8&gt;
<span class="lineNum">     543 </span>            : Args(const InnerMatcher&amp; matcher) {
<span class="lineNum">     544 </span>            :   return internal::ArgsMatcher&lt;InnerMatcher, k1, k2, k3, k4, k5, k6, k7,
<span class="lineNum">     545 </span>            :       k8&gt;(matcher);
<span class="lineNum">     546 </span>            : }
<span class="lineNum">     547 </span>            : 
<span class="lineNum">     548 </span>            : template &lt;int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
<span class="lineNum">     549 </span>            :     int k9, typename InnerMatcher&gt;
<span class="lineNum">     550 </span>            : inline internal::ArgsMatcher&lt;InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9&gt;
<span class="lineNum">     551 </span>            : Args(const InnerMatcher&amp; matcher) {
<span class="lineNum">     552 </span>            :   return internal::ArgsMatcher&lt;InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
<span class="lineNum">     553 </span>            :       k9&gt;(matcher);
<span class="lineNum">     554 </span>            : }
<span class="lineNum">     555 </span>            : 
<span class="lineNum">     556 </span>            : template &lt;int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
<span class="lineNum">     557 </span>            :     int k9, int k10, typename InnerMatcher&gt;
<span class="lineNum">     558 </span>            : inline internal::ArgsMatcher&lt;InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9,
<span class="lineNum">     559 </span>            :     k10&gt;
<span class="lineNum">     560 </span>            : Args(const InnerMatcher&amp; matcher) {
<span class="lineNum">     561 </span>            :   return internal::ArgsMatcher&lt;InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
<span class="lineNum">     562 </span>            :       k9, k10&gt;(matcher);
<span class="lineNum">     563 </span>            : }
<span class="lineNum">     564 </span>            : 
<span class="lineNum">     565 </span>            : // ElementsAre(e_1, e_2, ... e_n) matches an STL-style container with
<span class="lineNum">     566 </span>            : // n elements, where the i-th element in the container must
<span class="lineNum">     567 </span>            : // match the i-th argument in the list.  Each argument of
<span class="lineNum">     568 </span>            : // ElementsAre() can be either a value or a matcher.  We support up to
<span class="lineNum">     569 </span>            : // 10 arguments.
<span class="lineNum">     570 </span>            : //
<span class="lineNum">     571 </span>            : // The use of DecayArray in the implementation allows ElementsAre()
<span class="lineNum">     572 </span>            : // to accept string literals, whose type is const char[N], but we
<span class="lineNum">     573 </span>            : // want to treat them as const char*.
<span class="lineNum">     574 </span>            : //
<span class="lineNum">     575 </span>            : // NOTE: Since ElementsAre() cares about the order of the elements, it
<span class="lineNum">     576 </span>            : // must not be used with containers whose elements's order is
<span class="lineNum">     577 </span>            : // undefined (e.g. hash_map).
<span class="lineNum">     578 </span>            : 
<span class="lineNum">     579 </span>            : inline internal::ElementsAreMatcher&lt;
<span class="lineNum">     580 </span>            :     std::tr1::tuple&lt;&gt; &gt;
<span class="lineNum">     581 </span>            : ElementsAre() {
<span class="lineNum">     582 </span>            :   typedef std::tr1::tuple&lt;&gt; Args;
<span class="lineNum">     583 </span>            :   return internal::ElementsAreMatcher&lt;Args&gt;(Args());
<span class="lineNum">     584 </span>            : }
<span class="lineNum">     585 </span>            : 
<span class="lineNum">     586 </span>            : template &lt;typename T1&gt;
<span class="lineNum">     587 </span>            : inline internal::ElementsAreMatcher&lt;
<span class="lineNum">     588 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     589 </span>            :         typename internal::DecayArray&lt;T1&gt;::type&gt; &gt;
<span class="lineNum">     590 </span>            : ElementsAre(const T1&amp; e1) {
<span class="lineNum">     591 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     592 </span>            :       typename internal::DecayArray&lt;T1&gt;::type&gt; Args;
<span class="lineNum">     593 </span>            :   return internal::ElementsAreMatcher&lt;Args&gt;(Args(e1));
<span class="lineNum">     594 </span>            : }
<span class="lineNum">     595 </span>            : 
<span class="lineNum">     596 </span>            : template &lt;typename T1, typename T2&gt;
<span class="lineNum">     597 </span>            : inline internal::ElementsAreMatcher&lt;
<span class="lineNum">     598 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     599 </span>            :         typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     600 </span>            :         typename internal::DecayArray&lt;T2&gt;::type&gt; &gt;
<span class="lineNum">     601 </span>            : ElementsAre(const T1&amp; e1, const T2&amp; e2) {
<span class="lineNum">     602 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     603 </span>            :       typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     604 </span>            :       typename internal::DecayArray&lt;T2&gt;::type&gt; Args;
<span class="lineNum">     605 </span>            :   return internal::ElementsAreMatcher&lt;Args&gt;(Args(e1, e2));
<span class="lineNum">     606 </span>            : }
<span class="lineNum">     607 </span>            : 
<span class="lineNum">     608 </span>            : template &lt;typename T1, typename T2, typename T3&gt;
<span class="lineNum">     609 </span>            : inline internal::ElementsAreMatcher&lt;
<span class="lineNum">     610 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     611 </span>            :         typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     612 </span>            :         typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     613 </span>            :         typename internal::DecayArray&lt;T3&gt;::type&gt; &gt;
<span class="lineNum">     614 </span>            : ElementsAre(const T1&amp; e1, const T2&amp; e2, const T3&amp; e3) {
<span class="lineNum">     615 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     616 </span>            :       typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     617 </span>            :       typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     618 </span>            :       typename internal::DecayArray&lt;T3&gt;::type&gt; Args;
<span class="lineNum">     619 </span>            :   return internal::ElementsAreMatcher&lt;Args&gt;(Args(e1, e2, e3));
<span class="lineNum">     620 </span>            : }
<span class="lineNum">     621 </span>            : 
<span class="lineNum">     622 </span>            : template &lt;typename T1, typename T2, typename T3, typename T4&gt;
<span class="lineNum">     623 </span>            : inline internal::ElementsAreMatcher&lt;
<span class="lineNum">     624 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     625 </span>            :         typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     626 </span>            :         typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     627 </span>            :         typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     628 </span>            :         typename internal::DecayArray&lt;T4&gt;::type&gt; &gt;
<span class="lineNum">     629 </span>            : ElementsAre(const T1&amp; e1, const T2&amp; e2, const T3&amp; e3, const T4&amp; e4) {
<span class="lineNum">     630 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     631 </span>            :       typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     632 </span>            :       typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     633 </span>            :       typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     634 </span>            :       typename internal::DecayArray&lt;T4&gt;::type&gt; Args;
<span class="lineNum">     635 </span>            :   return internal::ElementsAreMatcher&lt;Args&gt;(Args(e1, e2, e3, e4));
<span class="lineNum">     636 </span>            : }
<span class="lineNum">     637 </span>            : 
<span class="lineNum">     638 </span>            : template &lt;typename T1, typename T2, typename T3, typename T4, typename T5&gt;
<span class="lineNum">     639 </span>            : inline internal::ElementsAreMatcher&lt;
<span class="lineNum">     640 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     641 </span>            :         typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     642 </span>            :         typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     643 </span>            :         typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     644 </span>            :         typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     645 </span>            :         typename internal::DecayArray&lt;T5&gt;::type&gt; &gt;
<span class="lineNum">     646 </span>            : ElementsAre(const T1&amp; e1, const T2&amp; e2, const T3&amp; e3, const T4&amp; e4,
<span class="lineNum">     647 </span>            :     const T5&amp; e5) {
<span class="lineNum">     648 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     649 </span>            :       typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     650 </span>            :       typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     651 </span>            :       typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     652 </span>            :       typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     653 </span>            :       typename internal::DecayArray&lt;T5&gt;::type&gt; Args;
<span class="lineNum">     654 </span>            :   return internal::ElementsAreMatcher&lt;Args&gt;(Args(e1, e2, e3, e4, e5));
<span class="lineNum">     655 </span>            : }
<span class="lineNum">     656 </span>            : 
<span class="lineNum">     657 </span>            : template &lt;typename T1, typename T2, typename T3, typename T4, typename T5,
<span class="lineNum">     658 </span>            :     typename T6&gt;
<span class="lineNum">     659 </span>            : inline internal::ElementsAreMatcher&lt;
<span class="lineNum">     660 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     661 </span>            :         typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     662 </span>            :         typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     663 </span>            :         typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     664 </span>            :         typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     665 </span>            :         typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     666 </span>            :         typename internal::DecayArray&lt;T6&gt;::type&gt; &gt;
<span class="lineNum">     667 </span>            : ElementsAre(const T1&amp; e1, const T2&amp; e2, const T3&amp; e3, const T4&amp; e4,
<span class="lineNum">     668 </span>            :     const T5&amp; e5, const T6&amp; e6) {
<span class="lineNum">     669 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     670 </span>            :       typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     671 </span>            :       typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     672 </span>            :       typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     673 </span>            :       typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     674 </span>            :       typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     675 </span>            :       typename internal::DecayArray&lt;T6&gt;::type&gt; Args;
<span class="lineNum">     676 </span>            :   return internal::ElementsAreMatcher&lt;Args&gt;(Args(e1, e2, e3, e4, e5, e6));
<span class="lineNum">     677 </span>            : }
<span class="lineNum">     678 </span>            : 
<span class="lineNum">     679 </span>            : template &lt;typename T1, typename T2, typename T3, typename T4, typename T5,
<span class="lineNum">     680 </span>            :     typename T6, typename T7&gt;
<span class="lineNum">     681 </span>            : inline internal::ElementsAreMatcher&lt;
<span class="lineNum">     682 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     683 </span>            :         typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     684 </span>            :         typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     685 </span>            :         typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     686 </span>            :         typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     687 </span>            :         typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     688 </span>            :         typename internal::DecayArray&lt;T6&gt;::type,
<span class="lineNum">     689 </span>            :         typename internal::DecayArray&lt;T7&gt;::type&gt; &gt;
<span class="lineNum">     690 </span>            : ElementsAre(const T1&amp; e1, const T2&amp; e2, const T3&amp; e3, const T4&amp; e4,
<span class="lineNum">     691 </span>            :     const T5&amp; e5, const T6&amp; e6, const T7&amp; e7) {
<span class="lineNum">     692 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     693 </span>            :       typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     694 </span>            :       typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     695 </span>            :       typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     696 </span>            :       typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     697 </span>            :       typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     698 </span>            :       typename internal::DecayArray&lt;T6&gt;::type,
<span class="lineNum">     699 </span>            :       typename internal::DecayArray&lt;T7&gt;::type&gt; Args;
<span class="lineNum">     700 </span>            :   return internal::ElementsAreMatcher&lt;Args&gt;(Args(e1, e2, e3, e4, e5, e6, e7));
<span class="lineNum">     701 </span>            : }
<span class="lineNum">     702 </span>            : 
<span class="lineNum">     703 </span>            : template &lt;typename T1, typename T2, typename T3, typename T4, typename T5,
<span class="lineNum">     704 </span>            :     typename T6, typename T7, typename T8&gt;
<span class="lineNum">     705 </span>            : inline internal::ElementsAreMatcher&lt;
<span class="lineNum">     706 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     707 </span>            :         typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     708 </span>            :         typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     709 </span>            :         typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     710 </span>            :         typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     711 </span>            :         typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     712 </span>            :         typename internal::DecayArray&lt;T6&gt;::type,
<span class="lineNum">     713 </span>            :         typename internal::DecayArray&lt;T7&gt;::type,
<span class="lineNum">     714 </span>            :         typename internal::DecayArray&lt;T8&gt;::type&gt; &gt;
<span class="lineNum">     715 </span>            : ElementsAre(const T1&amp; e1, const T2&amp; e2, const T3&amp; e3, const T4&amp; e4,
<span class="lineNum">     716 </span>            :     const T5&amp; e5, const T6&amp; e6, const T7&amp; e7, const T8&amp; e8) {
<span class="lineNum">     717 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     718 </span>            :       typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     719 </span>            :       typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     720 </span>            :       typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     721 </span>            :       typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     722 </span>            :       typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     723 </span>            :       typename internal::DecayArray&lt;T6&gt;::type,
<span class="lineNum">     724 </span>            :       typename internal::DecayArray&lt;T7&gt;::type,
<span class="lineNum">     725 </span>            :       typename internal::DecayArray&lt;T8&gt;::type&gt; Args;
<span class="lineNum">     726 </span>            :   return internal::ElementsAreMatcher&lt;Args&gt;(Args(e1, e2, e3, e4, e5, e6, e7,
<span class="lineNum">     727 </span>            :       e8));
<span class="lineNum">     728 </span>            : }
<span class="lineNum">     729 </span>            : 
<span class="lineNum">     730 </span>            : template &lt;typename T1, typename T2, typename T3, typename T4, typename T5,
<span class="lineNum">     731 </span>            :     typename T6, typename T7, typename T8, typename T9&gt;
<span class="lineNum">     732 </span>            : inline internal::ElementsAreMatcher&lt;
<span class="lineNum">     733 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     734 </span>            :         typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     735 </span>            :         typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     736 </span>            :         typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     737 </span>            :         typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     738 </span>            :         typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     739 </span>            :         typename internal::DecayArray&lt;T6&gt;::type,
<span class="lineNum">     740 </span>            :         typename internal::DecayArray&lt;T7&gt;::type,
<span class="lineNum">     741 </span>            :         typename internal::DecayArray&lt;T8&gt;::type,
<span class="lineNum">     742 </span>            :         typename internal::DecayArray&lt;T9&gt;::type&gt; &gt;
<span class="lineNum">     743 </span>            : ElementsAre(const T1&amp; e1, const T2&amp; e2, const T3&amp; e3, const T4&amp; e4,
<span class="lineNum">     744 </span>            :     const T5&amp; e5, const T6&amp; e6, const T7&amp; e7, const T8&amp; e8, const T9&amp; e9) {
<span class="lineNum">     745 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     746 </span>            :       typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     747 </span>            :       typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     748 </span>            :       typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     749 </span>            :       typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     750 </span>            :       typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     751 </span>            :       typename internal::DecayArray&lt;T6&gt;::type,
<span class="lineNum">     752 </span>            :       typename internal::DecayArray&lt;T7&gt;::type,
<span class="lineNum">     753 </span>            :       typename internal::DecayArray&lt;T8&gt;::type,
<span class="lineNum">     754 </span>            :       typename internal::DecayArray&lt;T9&gt;::type&gt; Args;
<span class="lineNum">     755 </span>            :   return internal::ElementsAreMatcher&lt;Args&gt;(Args(e1, e2, e3, e4, e5, e6, e7,
<span class="lineNum">     756 </span>            :       e8, e9));
<span class="lineNum">     757 </span>            : }
<span class="lineNum">     758 </span>            : 
<span class="lineNum">     759 </span>            : template &lt;typename T1, typename T2, typename T3, typename T4, typename T5,
<span class="lineNum">     760 </span>            :     typename T6, typename T7, typename T8, typename T9, typename T10&gt;
<span class="lineNum">     761 </span>            : inline internal::ElementsAreMatcher&lt;
<span class="lineNum">     762 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     763 </span>            :         typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     764 </span>            :         typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     765 </span>            :         typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     766 </span>            :         typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     767 </span>            :         typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     768 </span>            :         typename internal::DecayArray&lt;T6&gt;::type,
<span class="lineNum">     769 </span>            :         typename internal::DecayArray&lt;T7&gt;::type,
<span class="lineNum">     770 </span>            :         typename internal::DecayArray&lt;T8&gt;::type,
<span class="lineNum">     771 </span>            :         typename internal::DecayArray&lt;T9&gt;::type,
<span class="lineNum">     772 </span>            :         typename internal::DecayArray&lt;T10&gt;::type&gt; &gt;
<span class="lineNum">     773 </span>            : ElementsAre(const T1&amp; e1, const T2&amp; e2, const T3&amp; e3, const T4&amp; e4,
<span class="lineNum">     774 </span>            :     const T5&amp; e5, const T6&amp; e6, const T7&amp; e7, const T8&amp; e8, const T9&amp; e9,
<span class="lineNum">     775 </span>            :     const T10&amp; e10) {
<span class="lineNum">     776 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     777 </span>            :       typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     778 </span>            :       typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     779 </span>            :       typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     780 </span>            :       typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     781 </span>            :       typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     782 </span>            :       typename internal::DecayArray&lt;T6&gt;::type,
<span class="lineNum">     783 </span>            :       typename internal::DecayArray&lt;T7&gt;::type,
<span class="lineNum">     784 </span>            :       typename internal::DecayArray&lt;T8&gt;::type,
<span class="lineNum">     785 </span>            :       typename internal::DecayArray&lt;T9&gt;::type,
<span class="lineNum">     786 </span>            :       typename internal::DecayArray&lt;T10&gt;::type&gt; Args;
<span class="lineNum">     787 </span>            :   return internal::ElementsAreMatcher&lt;Args&gt;(Args(e1, e2, e3, e4, e5, e6, e7,
<span class="lineNum">     788 </span>            :       e8, e9, e10));
<span class="lineNum">     789 </span>            : }
<span class="lineNum">     790 </span>            : 
<span class="lineNum">     791 </span>            : // UnorderedElementsAre(e_1, e_2, ..., e_n) is an ElementsAre extension
<span class="lineNum">     792 </span>            : // that matches n elements in any order.  We support up to n=10 arguments.
<span class="lineNum">     793 </span>            : 
<span class="lineNum">     794 </span>            : inline internal::UnorderedElementsAreMatcher&lt;
<span class="lineNum">     795 </span>            :     std::tr1::tuple&lt;&gt; &gt;
<span class="lineNum">     796 </span>            : UnorderedElementsAre() {
<span class="lineNum">     797 </span>            :   typedef std::tr1::tuple&lt;&gt; Args;
<span class="lineNum">     798 </span>            :   return internal::UnorderedElementsAreMatcher&lt;Args&gt;(Args());
<span class="lineNum">     799 </span>            : }
<span class="lineNum">     800 </span>            : 
<span class="lineNum">     801 </span>            : template &lt;typename T1&gt;
<span class="lineNum">     802 </span>            : inline internal::UnorderedElementsAreMatcher&lt;
<span class="lineNum">     803 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     804 </span>            :         typename internal::DecayArray&lt;T1&gt;::type&gt; &gt;
<span class="lineNum">     805 </span>            : UnorderedElementsAre(const T1&amp; e1) {
<span class="lineNum">     806 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     807 </span>            :       typename internal::DecayArray&lt;T1&gt;::type&gt; Args;
<span class="lineNum">     808 </span>            :   return internal::UnorderedElementsAreMatcher&lt;Args&gt;(Args(e1));
<span class="lineNum">     809 </span>            : }
<span class="lineNum">     810 </span>            : 
<span class="lineNum">     811 </span>            : template &lt;typename T1, typename T2&gt;
<span class="lineNum">     812 </span>            : inline internal::UnorderedElementsAreMatcher&lt;
<span class="lineNum">     813 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     814 </span>            :         typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     815 </span>            :         typename internal::DecayArray&lt;T2&gt;::type&gt; &gt;
<span class="lineNum">     816 </span>            : UnorderedElementsAre(const T1&amp; e1, const T2&amp; e2) {
<span class="lineNum">     817 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     818 </span>            :       typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     819 </span>            :       typename internal::DecayArray&lt;T2&gt;::type&gt; Args;
<span class="lineNum">     820 </span>            :   return internal::UnorderedElementsAreMatcher&lt;Args&gt;(Args(e1, e2));
<span class="lineNum">     821 </span>            : }
<span class="lineNum">     822 </span>            : 
<span class="lineNum">     823 </span>            : template &lt;typename T1, typename T2, typename T3&gt;
<span class="lineNum">     824 </span>            : inline internal::UnorderedElementsAreMatcher&lt;
<span class="lineNum">     825 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     826 </span>            :         typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     827 </span>            :         typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     828 </span>            :         typename internal::DecayArray&lt;T3&gt;::type&gt; &gt;
<span class="lineNum">     829 </span>            : UnorderedElementsAre(const T1&amp; e1, const T2&amp; e2, const T3&amp; e3) {
<span class="lineNum">     830 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     831 </span>            :       typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     832 </span>            :       typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     833 </span>            :       typename internal::DecayArray&lt;T3&gt;::type&gt; Args;
<span class="lineNum">     834 </span>            :   return internal::UnorderedElementsAreMatcher&lt;Args&gt;(Args(e1, e2, e3));
<span class="lineNum">     835 </span>            : }
<span class="lineNum">     836 </span>            : 
<span class="lineNum">     837 </span>            : template &lt;typename T1, typename T2, typename T3, typename T4&gt;
<span class="lineNum">     838 </span>            : inline internal::UnorderedElementsAreMatcher&lt;
<span class="lineNum">     839 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     840 </span>            :         typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     841 </span>            :         typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     842 </span>            :         typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     843 </span>            :         typename internal::DecayArray&lt;T4&gt;::type&gt; &gt;
<span class="lineNum">     844 </span>            : UnorderedElementsAre(const T1&amp; e1, const T2&amp; e2, const T3&amp; e3, const T4&amp; e4) {
<span class="lineNum">     845 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     846 </span>            :       typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     847 </span>            :       typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     848 </span>            :       typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     849 </span>            :       typename internal::DecayArray&lt;T4&gt;::type&gt; Args;
<span class="lineNum">     850 </span>            :   return internal::UnorderedElementsAreMatcher&lt;Args&gt;(Args(e1, e2, e3, e4));
<span class="lineNum">     851 </span>            : }
<span class="lineNum">     852 </span>            : 
<span class="lineNum">     853 </span>            : template &lt;typename T1, typename T2, typename T3, typename T4, typename T5&gt;
<span class="lineNum">     854 </span>            : inline internal::UnorderedElementsAreMatcher&lt;
<span class="lineNum">     855 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     856 </span>            :         typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     857 </span>            :         typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     858 </span>            :         typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     859 </span>            :         typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     860 </span>            :         typename internal::DecayArray&lt;T5&gt;::type&gt; &gt;
<span class="lineNum">     861 </span>            : UnorderedElementsAre(const T1&amp; e1, const T2&amp; e2, const T3&amp; e3, const T4&amp; e4,
<span class="lineNum">     862 </span>            :     const T5&amp; e5) {
<span class="lineNum">     863 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     864 </span>            :       typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     865 </span>            :       typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     866 </span>            :       typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     867 </span>            :       typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     868 </span>            :       typename internal::DecayArray&lt;T5&gt;::type&gt; Args;
<span class="lineNum">     869 </span>            :   return internal::UnorderedElementsAreMatcher&lt;Args&gt;(Args(e1, e2, e3, e4, e5));
<span class="lineNum">     870 </span>            : }
<span class="lineNum">     871 </span>            : 
<span class="lineNum">     872 </span>            : template &lt;typename T1, typename T2, typename T3, typename T4, typename T5,
<span class="lineNum">     873 </span>            :     typename T6&gt;
<span class="lineNum">     874 </span>            : inline internal::UnorderedElementsAreMatcher&lt;
<span class="lineNum">     875 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     876 </span>            :         typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     877 </span>            :         typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     878 </span>            :         typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     879 </span>            :         typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     880 </span>            :         typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     881 </span>            :         typename internal::DecayArray&lt;T6&gt;::type&gt; &gt;
<span class="lineNum">     882 </span>            : UnorderedElementsAre(const T1&amp; e1, const T2&amp; e2, const T3&amp; e3, const T4&amp; e4,
<span class="lineNum">     883 </span>            :     const T5&amp; e5, const T6&amp; e6) {
<span class="lineNum">     884 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     885 </span>            :       typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     886 </span>            :       typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     887 </span>            :       typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     888 </span>            :       typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     889 </span>            :       typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     890 </span>            :       typename internal::DecayArray&lt;T6&gt;::type&gt; Args;
<span class="lineNum">     891 </span>            :   return internal::UnorderedElementsAreMatcher&lt;Args&gt;(Args(e1, e2, e3, e4, e5,
<span class="lineNum">     892 </span>            :       e6));
<span class="lineNum">     893 </span>            : }
<span class="lineNum">     894 </span>            : 
<span class="lineNum">     895 </span>            : template &lt;typename T1, typename T2, typename T3, typename T4, typename T5,
<span class="lineNum">     896 </span>            :     typename T6, typename T7&gt;
<span class="lineNum">     897 </span>            : inline internal::UnorderedElementsAreMatcher&lt;
<span class="lineNum">     898 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     899 </span>            :         typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     900 </span>            :         typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     901 </span>            :         typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     902 </span>            :         typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     903 </span>            :         typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     904 </span>            :         typename internal::DecayArray&lt;T6&gt;::type,
<span class="lineNum">     905 </span>            :         typename internal::DecayArray&lt;T7&gt;::type&gt; &gt;
<span class="lineNum">     906 </span>            : UnorderedElementsAre(const T1&amp; e1, const T2&amp; e2, const T3&amp; e3, const T4&amp; e4,
<span class="lineNum">     907 </span>            :     const T5&amp; e5, const T6&amp; e6, const T7&amp; e7) {
<span class="lineNum">     908 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     909 </span>            :       typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     910 </span>            :       typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     911 </span>            :       typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     912 </span>            :       typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     913 </span>            :       typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     914 </span>            :       typename internal::DecayArray&lt;T6&gt;::type,
<span class="lineNum">     915 </span>            :       typename internal::DecayArray&lt;T7&gt;::type&gt; Args;
<span class="lineNum">     916 </span>            :   return internal::UnorderedElementsAreMatcher&lt;Args&gt;(Args(e1, e2, e3, e4, e5,
<span class="lineNum">     917 </span>            :       e6, e7));
<span class="lineNum">     918 </span>            : }
<span class="lineNum">     919 </span>            : 
<span class="lineNum">     920 </span>            : template &lt;typename T1, typename T2, typename T3, typename T4, typename T5,
<span class="lineNum">     921 </span>            :     typename T6, typename T7, typename T8&gt;
<span class="lineNum">     922 </span>            : inline internal::UnorderedElementsAreMatcher&lt;
<span class="lineNum">     923 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     924 </span>            :         typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     925 </span>            :         typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     926 </span>            :         typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     927 </span>            :         typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     928 </span>            :         typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     929 </span>            :         typename internal::DecayArray&lt;T6&gt;::type,
<span class="lineNum">     930 </span>            :         typename internal::DecayArray&lt;T7&gt;::type,
<span class="lineNum">     931 </span>            :         typename internal::DecayArray&lt;T8&gt;::type&gt; &gt;
<span class="lineNum">     932 </span>            : UnorderedElementsAre(const T1&amp; e1, const T2&amp; e2, const T3&amp; e3, const T4&amp; e4,
<span class="lineNum">     933 </span>            :     const T5&amp; e5, const T6&amp; e6, const T7&amp; e7, const T8&amp; e8) {
<span class="lineNum">     934 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     935 </span>            :       typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     936 </span>            :       typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     937 </span>            :       typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     938 </span>            :       typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     939 </span>            :       typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     940 </span>            :       typename internal::DecayArray&lt;T6&gt;::type,
<span class="lineNum">     941 </span>            :       typename internal::DecayArray&lt;T7&gt;::type,
<span class="lineNum">     942 </span>            :       typename internal::DecayArray&lt;T8&gt;::type&gt; Args;
<span class="lineNum">     943 </span>            :   return internal::UnorderedElementsAreMatcher&lt;Args&gt;(Args(e1, e2, e3, e4, e5,
<span class="lineNum">     944 </span>            :       e6, e7, e8));
<span class="lineNum">     945 </span>            : }
<span class="lineNum">     946 </span>            : 
<span class="lineNum">     947 </span>            : template &lt;typename T1, typename T2, typename T3, typename T4, typename T5,
<span class="lineNum">     948 </span>            :     typename T6, typename T7, typename T8, typename T9&gt;
<span class="lineNum">     949 </span>            : inline internal::UnorderedElementsAreMatcher&lt;
<span class="lineNum">     950 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     951 </span>            :         typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     952 </span>            :         typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     953 </span>            :         typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     954 </span>            :         typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     955 </span>            :         typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     956 </span>            :         typename internal::DecayArray&lt;T6&gt;::type,
<span class="lineNum">     957 </span>            :         typename internal::DecayArray&lt;T7&gt;::type,
<span class="lineNum">     958 </span>            :         typename internal::DecayArray&lt;T8&gt;::type,
<span class="lineNum">     959 </span>            :         typename internal::DecayArray&lt;T9&gt;::type&gt; &gt;
<span class="lineNum">     960 </span>            : UnorderedElementsAre(const T1&amp; e1, const T2&amp; e2, const T3&amp; e3, const T4&amp; e4,
<span class="lineNum">     961 </span>            :     const T5&amp; e5, const T6&amp; e6, const T7&amp; e7, const T8&amp; e8, const T9&amp; e9) {
<span class="lineNum">     962 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     963 </span>            :       typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     964 </span>            :       typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     965 </span>            :       typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     966 </span>            :       typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     967 </span>            :       typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     968 </span>            :       typename internal::DecayArray&lt;T6&gt;::type,
<span class="lineNum">     969 </span>            :       typename internal::DecayArray&lt;T7&gt;::type,
<span class="lineNum">     970 </span>            :       typename internal::DecayArray&lt;T8&gt;::type,
<span class="lineNum">     971 </span>            :       typename internal::DecayArray&lt;T9&gt;::type&gt; Args;
<span class="lineNum">     972 </span>            :   return internal::UnorderedElementsAreMatcher&lt;Args&gt;(Args(e1, e2, e3, e4, e5,
<span class="lineNum">     973 </span>            :       e6, e7, e8, e9));
<span class="lineNum">     974 </span>            : }
<span class="lineNum">     975 </span>            : 
<span class="lineNum">     976 </span>            : template &lt;typename T1, typename T2, typename T3, typename T4, typename T5,
<span class="lineNum">     977 </span>            :     typename T6, typename T7, typename T8, typename T9, typename T10&gt;
<span class="lineNum">     978 </span>            : inline internal::UnorderedElementsAreMatcher&lt;
<span class="lineNum">     979 </span>            :     std::tr1::tuple&lt;
<span class="lineNum">     980 </span>            :         typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     981 </span>            :         typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     982 </span>            :         typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     983 </span>            :         typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     984 </span>            :         typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     985 </span>            :         typename internal::DecayArray&lt;T6&gt;::type,
<span class="lineNum">     986 </span>            :         typename internal::DecayArray&lt;T7&gt;::type,
<span class="lineNum">     987 </span>            :         typename internal::DecayArray&lt;T8&gt;::type,
<span class="lineNum">     988 </span>            :         typename internal::DecayArray&lt;T9&gt;::type,
<span class="lineNum">     989 </span>            :         typename internal::DecayArray&lt;T10&gt;::type&gt; &gt;
<span class="lineNum">     990 </span>            : UnorderedElementsAre(const T1&amp; e1, const T2&amp; e2, const T3&amp; e3, const T4&amp; e4,
<span class="lineNum">     991 </span>            :     const T5&amp; e5, const T6&amp; e6, const T7&amp; e7, const T8&amp; e8, const T9&amp; e9,
<span class="lineNum">     992 </span>            :     const T10&amp; e10) {
<span class="lineNum">     993 </span>            :   typedef std::tr1::tuple&lt;
<span class="lineNum">     994 </span>            :       typename internal::DecayArray&lt;T1&gt;::type,
<span class="lineNum">     995 </span>            :       typename internal::DecayArray&lt;T2&gt;::type,
<span class="lineNum">     996 </span>            :       typename internal::DecayArray&lt;T3&gt;::type,
<span class="lineNum">     997 </span>            :       typename internal::DecayArray&lt;T4&gt;::type,
<span class="lineNum">     998 </span>            :       typename internal::DecayArray&lt;T5&gt;::type,
<span class="lineNum">     999 </span>            :       typename internal::DecayArray&lt;T6&gt;::type,
<span class="lineNum">    1000 </span>            :       typename internal::DecayArray&lt;T7&gt;::type,
<span class="lineNum">    1001 </span>            :       typename internal::DecayArray&lt;T8&gt;::type,
<span class="lineNum">    1002 </span>            :       typename internal::DecayArray&lt;T9&gt;::type,
<span class="lineNum">    1003 </span>            :       typename internal::DecayArray&lt;T10&gt;::type&gt; Args;
<span class="lineNum">    1004 </span>            :   return internal::UnorderedElementsAreMatcher&lt;Args&gt;(Args(e1, e2, e3, e4, e5,
<span class="lineNum">    1005 </span>            :       e6, e7, e8, e9, e10));
<span class="lineNum">    1006 </span>            : }
<span class="lineNum">    1007 </span>            : 
<span class="lineNum">    1008 </span>            : // AllOf(m1, m2, ..., mk) matches any value that matches all of the given
<span class="lineNum">    1009 </span>            : // sub-matchers.  AllOf is called fully qualified to prevent ADL from firing.
<span class="lineNum">    1010 </span>            : 
<span class="lineNum">    1011 </span>            : template &lt;typename M1, typename M2&gt;
<span class="lineNum">    1012 </span>            : inline typename internal::AllOfResult2&lt;M1, M2&gt;::type
<span class="lineNum">    1013 </span>            : AllOf(M1 m1, M2 m2) {
<span class="lineNum">    1014 </span>            :   return typename internal::AllOfResult2&lt;M1, M2&gt;::type(
<span class="lineNum">    1015 </span>            :       m1,
<span class="lineNum">    1016 </span>            :       m2);
<span class="lineNum">    1017 </span>            : }
<span class="lineNum">    1018 </span>            : 
<span class="lineNum">    1019 </span>            : template &lt;typename M1, typename M2, typename M3&gt;
<span class="lineNum">    1020 </span>            : inline typename internal::AllOfResult3&lt;M1, M2, M3&gt;::type
<span class="lineNum">    1021 </span>            : AllOf(M1 m1, M2 m2, M3 m3) {
<span class="lineNum">    1022 </span>            :   return typename internal::AllOfResult3&lt;M1, M2, M3&gt;::type(
<span class="lineNum">    1023 </span>            :       m1,
<span class="lineNum">    1024 </span>            :       ::testing::AllOf(m2, m3));
<span class="lineNum">    1025 </span>            : }
<span class="lineNum">    1026 </span>            : 
<span class="lineNum">    1027 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4&gt;
<span class="lineNum">    1028 </span>            : inline typename internal::AllOfResult4&lt;M1, M2, M3, M4&gt;::type
<span class="lineNum">    1029 </span>            : AllOf(M1 m1, M2 m2, M3 m3, M4 m4) {
<span class="lineNum">    1030 </span>            :   return typename internal::AllOfResult4&lt;M1, M2, M3, M4&gt;::type(
<span class="lineNum">    1031 </span>            :       ::testing::AllOf(m1, m2),
<span class="lineNum">    1032 </span>            :       ::testing::AllOf(m3, m4));
<span class="lineNum">    1033 </span>            : }
<span class="lineNum">    1034 </span>            : 
<span class="lineNum">    1035 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5&gt;
<span class="lineNum">    1036 </span>            : inline typename internal::AllOfResult5&lt;M1, M2, M3, M4, M5&gt;::type
<span class="lineNum">    1037 </span>            : AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
<span class="lineNum">    1038 </span>            :   return typename internal::AllOfResult5&lt;M1, M2, M3, M4, M5&gt;::type(
<span class="lineNum">    1039 </span>            :       ::testing::AllOf(m1, m2),
<span class="lineNum">    1040 </span>            :       ::testing::AllOf(m3, m4, m5));
<span class="lineNum">    1041 </span>            : }
<span class="lineNum">    1042 </span>            : 
<span class="lineNum">    1043 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">    1044 </span>            :     typename M6&gt;
<span class="lineNum">    1045 </span>            : inline typename internal::AllOfResult6&lt;M1, M2, M3, M4, M5, M6&gt;::type
<span class="lineNum">    1046 </span>            : AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
<span class="lineNum">    1047 </span>            :   return typename internal::AllOfResult6&lt;M1, M2, M3, M4, M5, M6&gt;::type(
<span class="lineNum">    1048 </span>            :       ::testing::AllOf(m1, m2, m3),
<span class="lineNum">    1049 </span>            :       ::testing::AllOf(m4, m5, m6));
<span class="lineNum">    1050 </span>            : }
<span class="lineNum">    1051 </span>            : 
<span class="lineNum">    1052 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">    1053 </span>            :     typename M6, typename M7&gt;
<span class="lineNum">    1054 </span>            : inline typename internal::AllOfResult7&lt;M1, M2, M3, M4, M5, M6, M7&gt;::type
<span class="lineNum">    1055 </span>            : AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
<span class="lineNum">    1056 </span>            :   return typename internal::AllOfResult7&lt;M1, M2, M3, M4, M5, M6, M7&gt;::type(
<span class="lineNum">    1057 </span>            :       ::testing::AllOf(m1, m2, m3),
<span class="lineNum">    1058 </span>            :       ::testing::AllOf(m4, m5, m6, m7));
<span class="lineNum">    1059 </span>            : }
<span class="lineNum">    1060 </span>            : 
<span class="lineNum">    1061 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">    1062 </span>            :     typename M6, typename M7, typename M8&gt;
<span class="lineNum">    1063 </span>            : inline typename internal::AllOfResult8&lt;M1, M2, M3, M4, M5, M6, M7, M8&gt;::type
<span class="lineNum">    1064 </span>            : AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
<span class="lineNum">    1065 </span>            :   return typename internal::AllOfResult8&lt;M1, M2, M3, M4, M5, M6, M7, M8&gt;::type(
<span class="lineNum">    1066 </span>            :       ::testing::AllOf(m1, m2, m3, m4),
<span class="lineNum">    1067 </span>            :       ::testing::AllOf(m5, m6, m7, m8));
<span class="lineNum">    1068 </span>            : }
<span class="lineNum">    1069 </span>            : 
<span class="lineNum">    1070 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">    1071 </span>            :     typename M6, typename M7, typename M8, typename M9&gt;
<span class="lineNum">    1072 </span>            : inline typename internal::AllOfResult9&lt;M1, M2, M3, M4, M5, M6, M7, M8, M9&gt;::type
<span class="lineNum">    1073 </span>            : AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
<span class="lineNum">    1074 </span>            :   return typename internal::AllOfResult9&lt;M1, M2, M3, M4, M5, M6, M7, M8,
<span class="lineNum">    1075 </span>            :       M9&gt;::type(
<span class="lineNum">    1076 </span>            :       ::testing::AllOf(m1, m2, m3, m4),
<span class="lineNum">    1077 </span>            :       ::testing::AllOf(m5, m6, m7, m8, m9));
<span class="lineNum">    1078 </span>            : }
<span class="lineNum">    1079 </span>            : 
<span class="lineNum">    1080 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">    1081 </span>            :     typename M6, typename M7, typename M8, typename M9, typename M10&gt;
<span class="lineNum">    1082 </span>            : inline typename internal::AllOfResult10&lt;M1, M2, M3, M4, M5, M6, M7, M8, M9,
<span class="lineNum">    1083 </span>            :     M10&gt;::type
<span class="lineNum">    1084 </span>            : AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
<span class="lineNum">    1085 </span>            :   return typename internal::AllOfResult10&lt;M1, M2, M3, M4, M5, M6, M7, M8, M9,
<span class="lineNum">    1086 </span>            :       M10&gt;::type(
<span class="lineNum">    1087 </span>            :       ::testing::AllOf(m1, m2, m3, m4, m5),
<span class="lineNum">    1088 </span>            :       ::testing::AllOf(m6, m7, m8, m9, m10));
<span class="lineNum">    1089 </span>            : }
<span class="lineNum">    1090 </span>            : 
<span class="lineNum">    1091 </span>            : // AnyOf(m1, m2, ..., mk) matches any value that matches any of the given
<span class="lineNum">    1092 </span>            : // sub-matchers.  AnyOf is called fully qualified to prevent ADL from firing.
<span class="lineNum">    1093 </span>            : 
<a name="1094"><span class="lineNum">    1094 </span>            : template &lt;typename M1, typename M2&gt;</a>
<span class="lineNum">    1095 </span>            : inline typename internal::AnyOfResult2&lt;M1, M2&gt;::type
<span class="lineNum">    1096 </span><span class="lineNoCov">          0 : AnyOf(M1 m1, M2 m2) {</span>
<span class="lineNum">    1097 </span>            :   return typename internal::AnyOfResult2&lt;M1, M2&gt;::type(
<span class="lineNum">    1098 </span>            :       m1,
<span class="lineNum">    1099 </span><span class="lineNoCov">          0 :       m2);</span>
<span class="lineNum">    1100 </span>            : }
<span class="lineNum">    1101 </span>            : 
<span class="lineNum">    1102 </span>            : template &lt;typename M1, typename M2, typename M3&gt;
<span class="lineNum">    1103 </span>            : inline typename internal::AnyOfResult3&lt;M1, M2, M3&gt;::type
<span class="lineNum">    1104 </span>            : AnyOf(M1 m1, M2 m2, M3 m3) {
<span class="lineNum">    1105 </span>            :   return typename internal::AnyOfResult3&lt;M1, M2, M3&gt;::type(
<span class="lineNum">    1106 </span>            :       m1,
<span class="lineNum">    1107 </span>            :       ::testing::AnyOf(m2, m3));
<span class="lineNum">    1108 </span>            : }
<span class="lineNum">    1109 </span>            : 
<span class="lineNum">    1110 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4&gt;
<span class="lineNum">    1111 </span>            : inline typename internal::AnyOfResult4&lt;M1, M2, M3, M4&gt;::type
<span class="lineNum">    1112 </span>            : AnyOf(M1 m1, M2 m2, M3 m3, M4 m4) {
<span class="lineNum">    1113 </span>            :   return typename internal::AnyOfResult4&lt;M1, M2, M3, M4&gt;::type(
<span class="lineNum">    1114 </span>            :       ::testing::AnyOf(m1, m2),
<span class="lineNum">    1115 </span>            :       ::testing::AnyOf(m3, m4));
<span class="lineNum">    1116 </span>            : }
<span class="lineNum">    1117 </span>            : 
<span class="lineNum">    1118 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5&gt;
<span class="lineNum">    1119 </span>            : inline typename internal::AnyOfResult5&lt;M1, M2, M3, M4, M5&gt;::type
<span class="lineNum">    1120 </span>            : AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
<span class="lineNum">    1121 </span>            :   return typename internal::AnyOfResult5&lt;M1, M2, M3, M4, M5&gt;::type(
<span class="lineNum">    1122 </span>            :       ::testing::AnyOf(m1, m2),
<span class="lineNum">    1123 </span>            :       ::testing::AnyOf(m3, m4, m5));
<span class="lineNum">    1124 </span>            : }
<span class="lineNum">    1125 </span>            : 
<span class="lineNum">    1126 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">    1127 </span>            :     typename M6&gt;
<span class="lineNum">    1128 </span>            : inline typename internal::AnyOfResult6&lt;M1, M2, M3, M4, M5, M6&gt;::type
<span class="lineNum">    1129 </span>            : AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
<span class="lineNum">    1130 </span>            :   return typename internal::AnyOfResult6&lt;M1, M2, M3, M4, M5, M6&gt;::type(
<span class="lineNum">    1131 </span>            :       ::testing::AnyOf(m1, m2, m3),
<span class="lineNum">    1132 </span>            :       ::testing::AnyOf(m4, m5, m6));
<span class="lineNum">    1133 </span>            : }
<span class="lineNum">    1134 </span>            : 
<span class="lineNum">    1135 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">    1136 </span>            :     typename M6, typename M7&gt;
<span class="lineNum">    1137 </span>            : inline typename internal::AnyOfResult7&lt;M1, M2, M3, M4, M5, M6, M7&gt;::type
<span class="lineNum">    1138 </span>            : AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
<span class="lineNum">    1139 </span>            :   return typename internal::AnyOfResult7&lt;M1, M2, M3, M4, M5, M6, M7&gt;::type(
<span class="lineNum">    1140 </span>            :       ::testing::AnyOf(m1, m2, m3),
<span class="lineNum">    1141 </span>            :       ::testing::AnyOf(m4, m5, m6, m7));
<span class="lineNum">    1142 </span>            : }
<span class="lineNum">    1143 </span>            : 
<span class="lineNum">    1144 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">    1145 </span>            :     typename M6, typename M7, typename M8&gt;
<span class="lineNum">    1146 </span>            : inline typename internal::AnyOfResult8&lt;M1, M2, M3, M4, M5, M6, M7, M8&gt;::type
<span class="lineNum">    1147 </span>            : AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
<span class="lineNum">    1148 </span>            :   return typename internal::AnyOfResult8&lt;M1, M2, M3, M4, M5, M6, M7, M8&gt;::type(
<span class="lineNum">    1149 </span>            :       ::testing::AnyOf(m1, m2, m3, m4),
<span class="lineNum">    1150 </span>            :       ::testing::AnyOf(m5, m6, m7, m8));
<span class="lineNum">    1151 </span>            : }
<span class="lineNum">    1152 </span>            : 
<span class="lineNum">    1153 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">    1154 </span>            :     typename M6, typename M7, typename M8, typename M9&gt;
<span class="lineNum">    1155 </span>            : inline typename internal::AnyOfResult9&lt;M1, M2, M3, M4, M5, M6, M7, M8, M9&gt;::type
<span class="lineNum">    1156 </span>            : AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
<span class="lineNum">    1157 </span>            :   return typename internal::AnyOfResult9&lt;M1, M2, M3, M4, M5, M6, M7, M8,
<span class="lineNum">    1158 </span>            :       M9&gt;::type(
<span class="lineNum">    1159 </span>            :       ::testing::AnyOf(m1, m2, m3, m4),
<span class="lineNum">    1160 </span>            :       ::testing::AnyOf(m5, m6, m7, m8, m9));
<span class="lineNum">    1161 </span>            : }
<span class="lineNum">    1162 </span>            : 
<span class="lineNum">    1163 </span>            : template &lt;typename M1, typename M2, typename M3, typename M4, typename M5,
<span class="lineNum">    1164 </span>            :     typename M6, typename M7, typename M8, typename M9, typename M10&gt;
<span class="lineNum">    1165 </span>            : inline typename internal::AnyOfResult10&lt;M1, M2, M3, M4, M5, M6, M7, M8, M9,
<span class="lineNum">    1166 </span>            :     M10&gt;::type
<span class="lineNum">    1167 </span>            : AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
<span class="lineNum">    1168 </span>            :   return typename internal::AnyOfResult10&lt;M1, M2, M3, M4, M5, M6, M7, M8, M9,
<span class="lineNum">    1169 </span>            :       M10&gt;::type(
<span class="lineNum">    1170 </span>            :       ::testing::AnyOf(m1, m2, m3, m4, m5),
<span class="lineNum">    1171 </span>            :       ::testing::AnyOf(m6, m7, m8, m9, m10));
<span class="lineNum">    1172 </span>            : }
<span class="lineNum">    1173 </span>            : 
<span class="lineNum">    1174 </span>            : }  // namespace testing
<span class="lineNum">    1175 </span>            : 
<span class="lineNum">    1176 </span>            : 
<span class="lineNum">    1177 </span>            : // The MATCHER* family of macros can be used in a namespace scope to
<span class="lineNum">    1178 </span>            : // define custom matchers easily.
<span class="lineNum">    1179 </span>            : //
<span class="lineNum">    1180 </span>            : // Basic Usage
<span class="lineNum">    1181 </span>            : // ===========
<span class="lineNum">    1182 </span>            : //
<span class="lineNum">    1183 </span>            : // The syntax
<span class="lineNum">    1184 </span>            : //
<span class="lineNum">    1185 </span>            : //   MATCHER(name, description_string) { statements; }
<span class="lineNum">    1186 </span>            : //
<span class="lineNum">    1187 </span>            : // defines a matcher with the given name that executes the statements,
<span class="lineNum">    1188 </span>            : // which must return a bool to indicate if the match succeeds.  Inside
<span class="lineNum">    1189 </span>            : // the statements, you can refer to the value being matched by 'arg',
<span class="lineNum">    1190 </span>            : // and refer to its type by 'arg_type'.
<span class="lineNum">    1191 </span>            : //
<span class="lineNum">    1192 </span>            : // The description string documents what the matcher does, and is used
<span class="lineNum">    1193 </span>            : // to generate the failure message when the match fails.  Since a
<span class="lineNum">    1194 </span>            : // MATCHER() is usually defined in a header file shared by multiple
<span class="lineNum">    1195 </span>            : // C++ source files, we require the description to be a C-string
<span class="lineNum">    1196 </span>            : // literal to avoid possible side effects.  It can be empty, in which
<span class="lineNum">    1197 </span>            : // case we'll use the sequence of words in the matcher name as the
<span class="lineNum">    1198 </span>            : // description.
<span class="lineNum">    1199 </span>            : //
<span class="lineNum">    1200 </span>            : // For example:
<span class="lineNum">    1201 </span>            : //
<span class="lineNum">    1202 </span>            : //   MATCHER(IsEven, &quot;&quot;) { return (arg % 2) == 0; }
<span class="lineNum">    1203 </span>            : //
<span class="lineNum">    1204 </span>            : // allows you to write
<span class="lineNum">    1205 </span>            : //
<span class="lineNum">    1206 </span>            : //   // Expects mock_foo.Bar(n) to be called where n is even.
<span class="lineNum">    1207 </span>            : //   EXPECT_CALL(mock_foo, Bar(IsEven()));
<span class="lineNum">    1208 </span>            : //
<span class="lineNum">    1209 </span>            : // or,
<span class="lineNum">    1210 </span>            : //
<span class="lineNum">    1211 </span>            : //   // Verifies that the value of some_expression is even.
<span class="lineNum">    1212 </span>            : //   EXPECT_THAT(some_expression, IsEven());
<span class="lineNum">    1213 </span>            : //
<span class="lineNum">    1214 </span>            : // If the above assertion fails, it will print something like:
<span class="lineNum">    1215 </span>            : //
<span class="lineNum">    1216 </span>            : //   Value of: some_expression
<span class="lineNum">    1217 </span>            : //   Expected: is even
<span class="lineNum">    1218 </span>            : //     Actual: 7
<span class="lineNum">    1219 </span>            : //
<span class="lineNum">    1220 </span>            : // where the description &quot;is even&quot; is automatically calculated from the
<span class="lineNum">    1221 </span>            : // matcher name IsEven.
<span class="lineNum">    1222 </span>            : //
<span class="lineNum">    1223 </span>            : // Argument Type
<span class="lineNum">    1224 </span>            : // =============
<span class="lineNum">    1225 </span>            : //
<span class="lineNum">    1226 </span>            : // Note that the type of the value being matched (arg_type) is
<span class="lineNum">    1227 </span>            : // determined by the context in which you use the matcher and is
<span class="lineNum">    1228 </span>            : // supplied to you by the compiler, so you don't need to worry about
<span class="lineNum">    1229 </span>            : // declaring it (nor can you).  This allows the matcher to be
<span class="lineNum">    1230 </span>            : // polymorphic.  For example, IsEven() can be used to match any type
<span class="lineNum">    1231 </span>            : // where the value of &quot;(arg % 2) == 0&quot; can be implicitly converted to
<span class="lineNum">    1232 </span>            : // a bool.  In the &quot;Bar(IsEven())&quot; example above, if method Bar()
<span class="lineNum">    1233 </span>            : // takes an int, 'arg_type' will be int; if it takes an unsigned long,
<span class="lineNum">    1234 </span>            : // 'arg_type' will be unsigned long; and so on.
<span class="lineNum">    1235 </span>            : //
<span class="lineNum">    1236 </span>            : // Parameterizing Matchers
<span class="lineNum">    1237 </span>            : // =======================
<span class="lineNum">    1238 </span>            : //
<span class="lineNum">    1239 </span>            : // Sometimes you'll want to parameterize the matcher.  For that you
<span class="lineNum">    1240 </span>            : // can use another macro:
<span class="lineNum">    1241 </span>            : //
<span class="lineNum">    1242 </span>            : //   MATCHER_P(name, param_name, description_string) { statements; }
<span class="lineNum">    1243 </span>            : //
<span class="lineNum">    1244 </span>            : // For example:
<span class="lineNum">    1245 </span>            : //
<span class="lineNum">    1246 </span>            : //   MATCHER_P(HasAbsoluteValue, value, &quot;&quot;) { return abs(arg) == value; }
<span class="lineNum">    1247 </span>            : //
<span class="lineNum">    1248 </span>            : // will allow you to write:
<span class="lineNum">    1249 </span>            : //
<span class="lineNum">    1250 </span>            : //   EXPECT_THAT(Blah(&quot;a&quot;), HasAbsoluteValue(n));
<span class="lineNum">    1251 </span>            : //
<span class="lineNum">    1252 </span>            : // which may lead to this message (assuming n is 10):
<span class="lineNum">    1253 </span>            : //
<span class="lineNum">    1254 </span>            : //   Value of: Blah(&quot;a&quot;)
<span class="lineNum">    1255 </span>            : //   Expected: has absolute value 10
<span class="lineNum">    1256 </span>            : //     Actual: -9
<span class="lineNum">    1257 </span>            : //
<span class="lineNum">    1258 </span>            : // Note that both the matcher description and its parameter are
<span class="lineNum">    1259 </span>            : // printed, making the message human-friendly.
<span class="lineNum">    1260 </span>            : //
<span class="lineNum">    1261 </span>            : // In the matcher definition body, you can write 'foo_type' to
<span class="lineNum">    1262 </span>            : // reference the type of a parameter named 'foo'.  For example, in the
<span class="lineNum">    1263 </span>            : // body of MATCHER_P(HasAbsoluteValue, value) above, you can write
<span class="lineNum">    1264 </span>            : // 'value_type' to refer to the type of 'value'.
<span class="lineNum">    1265 </span>            : //
<span class="lineNum">    1266 </span>            : // We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P10 to
<span class="lineNum">    1267 </span>            : // support multi-parameter matchers.
<span class="lineNum">    1268 </span>            : //
<span class="lineNum">    1269 </span>            : // Describing Parameterized Matchers
<span class="lineNum">    1270 </span>            : // =================================
<span class="lineNum">    1271 </span>            : //
<span class="lineNum">    1272 </span>            : // The last argument to MATCHER*() is a string-typed expression.  The
<span class="lineNum">    1273 </span>            : // expression can reference all of the matcher's parameters and a
<span class="lineNum">    1274 </span>            : // special bool-typed variable named 'negation'.  When 'negation' is
<span class="lineNum">    1275 </span>            : // false, the expression should evaluate to the matcher's description;
<span class="lineNum">    1276 </span>            : // otherwise it should evaluate to the description of the negation of
<span class="lineNum">    1277 </span>            : // the matcher.  For example,
<span class="lineNum">    1278 </span>            : //
<span class="lineNum">    1279 </span>            : //   using testing::PrintToString;
<span class="lineNum">    1280 </span>            : //
<span class="lineNum">    1281 </span>            : //   MATCHER_P2(InClosedRange, low, hi,
<span class="lineNum">    1282 </span>            : //       string(negation ? &quot;is not&quot; : &quot;is&quot;) + &quot; in range [&quot; +
<span class="lineNum">    1283 </span>            : //       PrintToString(low) + &quot;, &quot; + PrintToString(hi) + &quot;]&quot;) {
<span class="lineNum">    1284 </span>            : //     return low &lt;= arg &amp;&amp; arg &lt;= hi;
<span class="lineNum">    1285 </span>            : //   }
<span class="lineNum">    1286 </span>            : //   ...
<span class="lineNum">    1287 </span>            : //   EXPECT_THAT(3, InClosedRange(4, 6));
<span class="lineNum">    1288 </span>            : //   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
<span class="lineNum">    1289 </span>            : //
<span class="lineNum">    1290 </span>            : // would generate two failures that contain the text:
<span class="lineNum">    1291 </span>            : //
<span class="lineNum">    1292 </span>            : //   Expected: is in range [4, 6]
<span class="lineNum">    1293 </span>            : //   ...
<span class="lineNum">    1294 </span>            : //   Expected: is not in range [2, 4]
<span class="lineNum">    1295 </span>            : //
<span class="lineNum">    1296 </span>            : // If you specify &quot;&quot; as the description, the failure message will
<span class="lineNum">    1297 </span>            : // contain the sequence of words in the matcher name followed by the
<span class="lineNum">    1298 </span>            : // parameter values printed as a tuple.  For example,
<span class="lineNum">    1299 </span>            : //
<span class="lineNum">    1300 </span>            : //   MATCHER_P2(InClosedRange, low, hi, &quot;&quot;) { ... }
<span class="lineNum">    1301 </span>            : //   ...
<span class="lineNum">    1302 </span>            : //   EXPECT_THAT(3, InClosedRange(4, 6));
<span class="lineNum">    1303 </span>            : //   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
<span class="lineNum">    1304 </span>            : //
<span class="lineNum">    1305 </span>            : // would generate two failures that contain the text:
<span class="lineNum">    1306 </span>            : //
<span class="lineNum">    1307 </span>            : //   Expected: in closed range (4, 6)
<span class="lineNum">    1308 </span>            : //   ...
<span class="lineNum">    1309 </span>            : //   Expected: not (in closed range (2, 4))
<span class="lineNum">    1310 </span>            : //
<span class="lineNum">    1311 </span>            : // Types of Matcher Parameters
<span class="lineNum">    1312 </span>            : // ===========================
<span class="lineNum">    1313 </span>            : //
<span class="lineNum">    1314 </span>            : // For the purpose of typing, you can view
<span class="lineNum">    1315 </span>            : //
<span class="lineNum">    1316 </span>            : //   MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }
<span class="lineNum">    1317 </span>            : //
<span class="lineNum">    1318 </span>            : // as shorthand for
<span class="lineNum">    1319 </span>            : //
<span class="lineNum">    1320 </span>            : //   template &lt;typename p1_type, ..., typename pk_type&gt;
<span class="lineNum">    1321 </span>            : //   FooMatcherPk&lt;p1_type, ..., pk_type&gt;
<span class="lineNum">    1322 </span>            : //   Foo(p1_type p1, ..., pk_type pk) { ... }
<span class="lineNum">    1323 </span>            : //
<span class="lineNum">    1324 </span>            : // When you write Foo(v1, ..., vk), the compiler infers the types of
<span class="lineNum">    1325 </span>            : // the parameters v1, ..., and vk for you.  If you are not happy with
<span class="lineNum">    1326 </span>            : // the result of the type inference, you can specify the types by
<span class="lineNum">    1327 </span>            : // explicitly instantiating the template, as in Foo&lt;long, bool&gt;(5,
<span class="lineNum">    1328 </span>            : // false).  As said earlier, you don't get to (or need to) specify
<span class="lineNum">    1329 </span>            : // 'arg_type' as that's determined by the context in which the matcher
<span class="lineNum">    1330 </span>            : // is used.  You can assign the result of expression Foo(p1, ..., pk)
<span class="lineNum">    1331 </span>            : // to a variable of type FooMatcherPk&lt;p1_type, ..., pk_type&gt;.  This
<span class="lineNum">    1332 </span>            : // can be useful when composing matchers.
<span class="lineNum">    1333 </span>            : //
<span class="lineNum">    1334 </span>            : // While you can instantiate a matcher template with reference types,
<span class="lineNum">    1335 </span>            : // passing the parameters by pointer usually makes your code more
<span class="lineNum">    1336 </span>            : // readable.  If, however, you still want to pass a parameter by
<span class="lineNum">    1337 </span>            : // reference, be aware that in the failure message generated by the
<span class="lineNum">    1338 </span>            : // matcher you will see the value of the referenced object but not its
<span class="lineNum">    1339 </span>            : // address.
<span class="lineNum">    1340 </span>            : //
<span class="lineNum">    1341 </span>            : // Explaining Match Results
<span class="lineNum">    1342 </span>            : // ========================
<span class="lineNum">    1343 </span>            : //
<span class="lineNum">    1344 </span>            : // Sometimes the matcher description alone isn't enough to explain why
<span class="lineNum">    1345 </span>            : // the match has failed or succeeded.  For example, when expecting a
<span class="lineNum">    1346 </span>            : // long string, it can be very helpful to also print the diff between
<span class="lineNum">    1347 </span>            : // the expected string and the actual one.  To achieve that, you can
<span class="lineNum">    1348 </span>            : // optionally stream additional information to a special variable
<span class="lineNum">    1349 </span>            : // named result_listener, whose type is a pointer to class
<span class="lineNum">    1350 </span>            : // MatchResultListener:
<span class="lineNum">    1351 </span>            : //
<span class="lineNum">    1352 </span>            : //   MATCHER_P(EqualsLongString, str, &quot;&quot;) {
<span class="lineNum">    1353 </span>            : //     if (arg == str) return true;
<span class="lineNum">    1354 </span>            : //
<span class="lineNum">    1355 </span>            : //     *result_listener &lt;&lt; &quot;the difference: &quot;
<span class="lineNum">    1356 </span>            : ///                     &lt;&lt; DiffStrings(str, arg);
<span class="lineNum">    1357 </span>            : //     return false;
<span class="lineNum">    1358 </span>            : //   }
<span class="lineNum">    1359 </span>            : //
<span class="lineNum">    1360 </span>            : // Overloading Matchers
<span class="lineNum">    1361 </span>            : // ====================
<span class="lineNum">    1362 </span>            : //
<span class="lineNum">    1363 </span>            : // You can overload matchers with different numbers of parameters:
<span class="lineNum">    1364 </span>            : //
<span class="lineNum">    1365 </span>            : //   MATCHER_P(Blah, a, description_string1) { ... }
<span class="lineNum">    1366 </span>            : //   MATCHER_P2(Blah, a, b, description_string2) { ... }
<span class="lineNum">    1367 </span>            : //
<span class="lineNum">    1368 </span>            : // Caveats
<span class="lineNum">    1369 </span>            : // =======
<span class="lineNum">    1370 </span>            : //
<span class="lineNum">    1371 </span>            : // When defining a new matcher, you should also consider implementing
<span class="lineNum">    1372 </span>            : // MatcherInterface or using MakePolymorphicMatcher().  These
<span class="lineNum">    1373 </span>            : // approaches require more work than the MATCHER* macros, but also
<span class="lineNum">    1374 </span>            : // give you more control on the types of the value being matched and
<span class="lineNum">    1375 </span>            : // the matcher parameters, which may leads to better compiler error
<span class="lineNum">    1376 </span>            : // messages when the matcher is used wrong.  They also allow
<span class="lineNum">    1377 </span>            : // overloading matchers based on parameter types (as opposed to just
<span class="lineNum">    1378 </span>            : // based on the number of parameters).
<span class="lineNum">    1379 </span>            : //
<span class="lineNum">    1380 </span>            : // MATCHER*() can only be used in a namespace scope.  The reason is
<span class="lineNum">    1381 </span>            : // that C++ doesn't yet allow function-local types to be used to
<span class="lineNum">    1382 </span>            : // instantiate templates.  The up-coming C++0x standard will fix this.
<span class="lineNum">    1383 </span>            : // Once that's done, we'll consider supporting using MATCHER*() inside
<span class="lineNum">    1384 </span>            : // a function.
<span class="lineNum">    1385 </span>            : //
<span class="lineNum">    1386 </span>            : // More Information
<span class="lineNum">    1387 </span>            : // ================
<span class="lineNum">    1388 </span>            : //
<span class="lineNum">    1389 </span>            : // To learn more about using these macros, please search for 'MATCHER'
<span class="lineNum">    1390 </span>            : // on http://code.google.com/p/googlemock/wiki/CookBook.
<span class="lineNum">    1391 </span>            : 
<span class="lineNum">    1392 </span>            : #define MATCHER(name, description)\
<span class="lineNum">    1393 </span>            :   class name##Matcher {\
<span class="lineNum">    1394 </span>            :    public:\
<span class="lineNum">    1395 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    1396 </span>            :     class gmock_Impl : public ::testing::MatcherInterface&lt;arg_type&gt; {\
<span class="lineNum">    1397 </span>            :      public:\
<span class="lineNum">    1398 </span>            :       gmock_Impl()\
<span class="lineNum">    1399 </span>            :            {}\
<span class="lineNum">    1400 </span>            :       virtual bool MatchAndExplain(\
<span class="lineNum">    1401 </span>            :           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
<span class="lineNum">    1402 </span>            :       virtual void DescribeTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    1403 </span>            :         *gmock_os &lt;&lt; FormatDescription(false);\
<span class="lineNum">    1404 </span>            :       }\
<span class="lineNum">    1405 </span>            :       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    1406 </span>            :         *gmock_os &lt;&lt; FormatDescription(true);\
<span class="lineNum">    1407 </span>            :       }\
<span class="lineNum">    1408 </span>            :      private:\
<span class="lineNum">    1409 </span>            :       ::testing::internal::string FormatDescription(bool negation) const {\
<span class="lineNum">    1410 </span>            :         const ::testing::internal::string gmock_description = (description);\
<span class="lineNum">    1411 </span>            :         if (!gmock_description.empty())\
<span class="lineNum">    1412 </span>            :           return gmock_description;\
<span class="lineNum">    1413 </span>            :         return ::testing::internal::FormatMatcherDescription(\
<span class="lineNum">    1414 </span>            :             negation, #name, \
<span class="lineNum">    1415 </span>            :             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
<span class="lineNum">    1416 </span>            :                 ::std::tr1::tuple&lt;&gt;()));\
<span class="lineNum">    1417 </span>            :       }\
<span class="lineNum">    1418 </span>            :       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
<span class="lineNum">    1419 </span>            :     };\
<span class="lineNum">    1420 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    1421 </span>            :     operator ::testing::Matcher&lt;arg_type&gt;() const {\
<span class="lineNum">    1422 </span>            :       return ::testing::Matcher&lt;arg_type&gt;(\
<span class="lineNum">    1423 </span>            :           new gmock_Impl&lt;arg_type&gt;());\
<span class="lineNum">    1424 </span>            :     }\
<span class="lineNum">    1425 </span>            :     name##Matcher() {\
<span class="lineNum">    1426 </span>            :     }\
<span class="lineNum">    1427 </span>            :    private:\
<span class="lineNum">    1428 </span>            :     GTEST_DISALLOW_ASSIGN_(name##Matcher);\
<span class="lineNum">    1429 </span>            :   };\
<span class="lineNum">    1430 </span>            :   inline name##Matcher name() {\
<span class="lineNum">    1431 </span>            :     return name##Matcher();\
<span class="lineNum">    1432 </span>            :   }\
<span class="lineNum">    1433 </span>            :   template &lt;typename arg_type&gt;\
<span class="lineNum">    1434 </span>            :   bool name##Matcher::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(\
<span class="lineNum">    1435 </span>            :       arg_type arg, \
<span class="lineNum">    1436 </span>            :       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
<span class="lineNum">    1437 </span>            :           const
<span class="lineNum">    1438 </span>            : 
<span class="lineNum">    1439 </span>            : #define MATCHER_P(name, p0, description)\
<span class="lineNum">    1440 </span>            :   template &lt;typename p0##_type&gt;\
<span class="lineNum">    1441 </span>            :   class name##MatcherP {\
<span class="lineNum">    1442 </span>            :    public:\
<span class="lineNum">    1443 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    1444 </span>            :     class gmock_Impl : public ::testing::MatcherInterface&lt;arg_type&gt; {\
<span class="lineNum">    1445 </span>            :      public:\
<span class="lineNum">    1446 </span>            :       explicit gmock_Impl(p0##_type gmock_p0)\
<span class="lineNum">    1447 </span>            :            : p0(gmock_p0) {}\
<span class="lineNum">    1448 </span>            :       virtual bool MatchAndExplain(\
<span class="lineNum">    1449 </span>            :           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
<span class="lineNum">    1450 </span>            :       virtual void DescribeTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    1451 </span>            :         *gmock_os &lt;&lt; FormatDescription(false);\
<span class="lineNum">    1452 </span>            :       }\
<span class="lineNum">    1453 </span>            :       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    1454 </span>            :         *gmock_os &lt;&lt; FormatDescription(true);\
<span class="lineNum">    1455 </span>            :       }\
<span class="lineNum">    1456 </span>            :       p0##_type p0;\
<span class="lineNum">    1457 </span>            :      private:\
<span class="lineNum">    1458 </span>            :       ::testing::internal::string FormatDescription(bool negation) const {\
<span class="lineNum">    1459 </span>            :         const ::testing::internal::string gmock_description = (description);\
<span class="lineNum">    1460 </span>            :         if (!gmock_description.empty())\
<span class="lineNum">    1461 </span>            :           return gmock_description;\
<span class="lineNum">    1462 </span>            :         return ::testing::internal::FormatMatcherDescription(\
<span class="lineNum">    1463 </span>            :             negation, #name, \
<span class="lineNum">    1464 </span>            :             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
<span class="lineNum">    1465 </span>            :                 ::std::tr1::tuple&lt;p0##_type&gt;(p0)));\
<span class="lineNum">    1466 </span>            :       }\
<span class="lineNum">    1467 </span>            :       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
<span class="lineNum">    1468 </span>            :     };\
<span class="lineNum">    1469 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    1470 </span>            :     operator ::testing::Matcher&lt;arg_type&gt;() const {\
<span class="lineNum">    1471 </span>            :       return ::testing::Matcher&lt;arg_type&gt;(\
<span class="lineNum">    1472 </span>            :           new gmock_Impl&lt;arg_type&gt;(p0));\
<span class="lineNum">    1473 </span>            :     }\
<span class="lineNum">    1474 </span>            :     name##MatcherP(p0##_type gmock_p0) : p0(gmock_p0) {\
<span class="lineNum">    1475 </span>            :     }\
<span class="lineNum">    1476 </span>            :     p0##_type p0;\
<span class="lineNum">    1477 </span>            :    private:\
<span class="lineNum">    1478 </span>            :     GTEST_DISALLOW_ASSIGN_(name##MatcherP);\
<span class="lineNum">    1479 </span>            :   };\
<span class="lineNum">    1480 </span>            :   template &lt;typename p0##_type&gt;\
<span class="lineNum">    1481 </span>            :   inline name##MatcherP&lt;p0##_type&gt; name(p0##_type p0) {\
<span class="lineNum">    1482 </span>            :     return name##MatcherP&lt;p0##_type&gt;(p0);\
<span class="lineNum">    1483 </span>            :   }\
<span class="lineNum">    1484 </span>            :   template &lt;typename p0##_type&gt;\
<span class="lineNum">    1485 </span>            :   template &lt;typename arg_type&gt;\
<span class="lineNum">    1486 </span>            :   bool name##MatcherP&lt;p0##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(\
<span class="lineNum">    1487 </span>            :       arg_type arg, \
<span class="lineNum">    1488 </span>            :       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
<span class="lineNum">    1489 </span>            :           const
<span class="lineNum">    1490 </span>            : 
<span class="lineNum">    1491 </span>            : #define MATCHER_P2(name, p0, p1, description)\
<span class="lineNum">    1492 </span>            :   template &lt;typename p0##_type, typename p1##_type&gt;\
<span class="lineNum">    1493 </span>            :   class name##MatcherP2 {\
<span class="lineNum">    1494 </span>            :    public:\
<span class="lineNum">    1495 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    1496 </span>            :     class gmock_Impl : public ::testing::MatcherInterface&lt;arg_type&gt; {\
<span class="lineNum">    1497 </span>            :      public:\
<span class="lineNum">    1498 </span>            :       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1)\
<span class="lineNum">    1499 </span>            :            : p0(gmock_p0), p1(gmock_p1) {}\
<span class="lineNum">    1500 </span>            :       virtual bool MatchAndExplain(\
<span class="lineNum">    1501 </span>            :           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
<span class="lineNum">    1502 </span>            :       virtual void DescribeTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    1503 </span>            :         *gmock_os &lt;&lt; FormatDescription(false);\
<span class="lineNum">    1504 </span>            :       }\
<span class="lineNum">    1505 </span>            :       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    1506 </span>            :         *gmock_os &lt;&lt; FormatDescription(true);\
<span class="lineNum">    1507 </span>            :       }\
<span class="lineNum">    1508 </span>            :       p0##_type p0;\
<span class="lineNum">    1509 </span>            :       p1##_type p1;\
<span class="lineNum">    1510 </span>            :      private:\
<span class="lineNum">    1511 </span>            :       ::testing::internal::string FormatDescription(bool negation) const {\
<span class="lineNum">    1512 </span>            :         const ::testing::internal::string gmock_description = (description);\
<span class="lineNum">    1513 </span>            :         if (!gmock_description.empty())\
<span class="lineNum">    1514 </span>            :           return gmock_description;\
<span class="lineNum">    1515 </span>            :         return ::testing::internal::FormatMatcherDescription(\
<span class="lineNum">    1516 </span>            :             negation, #name, \
<span class="lineNum">    1517 </span>            :             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
<span class="lineNum">    1518 </span>            :                 ::std::tr1::tuple&lt;p0##_type, p1##_type&gt;(p0, p1)));\
<span class="lineNum">    1519 </span>            :       }\
<span class="lineNum">    1520 </span>            :       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
<span class="lineNum">    1521 </span>            :     };\
<span class="lineNum">    1522 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    1523 </span>            :     operator ::testing::Matcher&lt;arg_type&gt;() const {\
<span class="lineNum">    1524 </span>            :       return ::testing::Matcher&lt;arg_type&gt;(\
<span class="lineNum">    1525 </span>            :           new gmock_Impl&lt;arg_type&gt;(p0, p1));\
<span class="lineNum">    1526 </span>            :     }\
<span class="lineNum">    1527 </span>            :     name##MatcherP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
<span class="lineNum">    1528 </span>            :         p1(gmock_p1) {\
<span class="lineNum">    1529 </span>            :     }\
<span class="lineNum">    1530 </span>            :     p0##_type p0;\
<span class="lineNum">    1531 </span>            :     p1##_type p1;\
<span class="lineNum">    1532 </span>            :    private:\
<span class="lineNum">    1533 </span>            :     GTEST_DISALLOW_ASSIGN_(name##MatcherP2);\
<span class="lineNum">    1534 </span>            :   };\
<span class="lineNum">    1535 </span>            :   template &lt;typename p0##_type, typename p1##_type&gt;\
<span class="lineNum">    1536 </span>            :   inline name##MatcherP2&lt;p0##_type, p1##_type&gt; name(p0##_type p0, \
<span class="lineNum">    1537 </span>            :       p1##_type p1) {\
<span class="lineNum">    1538 </span>            :     return name##MatcherP2&lt;p0##_type, p1##_type&gt;(p0, p1);\
<span class="lineNum">    1539 </span>            :   }\
<span class="lineNum">    1540 </span>            :   template &lt;typename p0##_type, typename p1##_type&gt;\
<span class="lineNum">    1541 </span>            :   template &lt;typename arg_type&gt;\
<span class="lineNum">    1542 </span>            :   bool name##MatcherP2&lt;p0##_type, \
<span class="lineNum">    1543 </span>            :       p1##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(\
<span class="lineNum">    1544 </span>            :       arg_type arg, \
<span class="lineNum">    1545 </span>            :       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
<span class="lineNum">    1546 </span>            :           const
<span class="lineNum">    1547 </span>            : 
<span class="lineNum">    1548 </span>            : #define MATCHER_P3(name, p0, p1, p2, description)\
<span class="lineNum">    1549 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type&gt;\
<span class="lineNum">    1550 </span>            :   class name##MatcherP3 {\
<span class="lineNum">    1551 </span>            :    public:\
<span class="lineNum">    1552 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    1553 </span>            :     class gmock_Impl : public ::testing::MatcherInterface&lt;arg_type&gt; {\
<span class="lineNum">    1554 </span>            :      public:\
<span class="lineNum">    1555 </span>            :       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2)\
<span class="lineNum">    1556 </span>            :            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
<span class="lineNum">    1557 </span>            :       virtual bool MatchAndExplain(\
<span class="lineNum">    1558 </span>            :           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
<span class="lineNum">    1559 </span>            :       virtual void DescribeTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    1560 </span>            :         *gmock_os &lt;&lt; FormatDescription(false);\
<span class="lineNum">    1561 </span>            :       }\
<span class="lineNum">    1562 </span>            :       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    1563 </span>            :         *gmock_os &lt;&lt; FormatDescription(true);\
<span class="lineNum">    1564 </span>            :       }\
<span class="lineNum">    1565 </span>            :       p0##_type p0;\
<span class="lineNum">    1566 </span>            :       p1##_type p1;\
<span class="lineNum">    1567 </span>            :       p2##_type p2;\
<span class="lineNum">    1568 </span>            :      private:\
<span class="lineNum">    1569 </span>            :       ::testing::internal::string FormatDescription(bool negation) const {\
<span class="lineNum">    1570 </span>            :         const ::testing::internal::string gmock_description = (description);\
<span class="lineNum">    1571 </span>            :         if (!gmock_description.empty())\
<span class="lineNum">    1572 </span>            :           return gmock_description;\
<span class="lineNum">    1573 </span>            :         return ::testing::internal::FormatMatcherDescription(\
<span class="lineNum">    1574 </span>            :             negation, #name, \
<span class="lineNum">    1575 </span>            :             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
<span class="lineNum">    1576 </span>            :                 ::std::tr1::tuple&lt;p0##_type, p1##_type, p2##_type&gt;(p0, p1, \
<span class="lineNum">    1577 </span>            :                     p2)));\
<span class="lineNum">    1578 </span>            :       }\
<span class="lineNum">    1579 </span>            :       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
<span class="lineNum">    1580 </span>            :     };\
<span class="lineNum">    1581 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    1582 </span>            :     operator ::testing::Matcher&lt;arg_type&gt;() const {\
<span class="lineNum">    1583 </span>            :       return ::testing::Matcher&lt;arg_type&gt;(\
<span class="lineNum">    1584 </span>            :           new gmock_Impl&lt;arg_type&gt;(p0, p1, p2));\
<span class="lineNum">    1585 </span>            :     }\
<span class="lineNum">    1586 </span>            :     name##MatcherP3(p0##_type gmock_p0, p1##_type gmock_p1, \
<span class="lineNum">    1587 </span>            :         p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {\
<span class="lineNum">    1588 </span>            :     }\
<span class="lineNum">    1589 </span>            :     p0##_type p0;\
<span class="lineNum">    1590 </span>            :     p1##_type p1;\
<span class="lineNum">    1591 </span>            :     p2##_type p2;\
<span class="lineNum">    1592 </span>            :    private:\
<span class="lineNum">    1593 </span>            :     GTEST_DISALLOW_ASSIGN_(name##MatcherP3);\
<span class="lineNum">    1594 </span>            :   };\
<span class="lineNum">    1595 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type&gt;\
<span class="lineNum">    1596 </span>            :   inline name##MatcherP3&lt;p0##_type, p1##_type, p2##_type&gt; name(p0##_type p0, \
<span class="lineNum">    1597 </span>            :       p1##_type p1, p2##_type p2) {\
<span class="lineNum">    1598 </span>            :     return name##MatcherP3&lt;p0##_type, p1##_type, p2##_type&gt;(p0, p1, p2);\
<span class="lineNum">    1599 </span>            :   }\
<span class="lineNum">    1600 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type&gt;\
<span class="lineNum">    1601 </span>            :   template &lt;typename arg_type&gt;\
<span class="lineNum">    1602 </span>            :   bool name##MatcherP3&lt;p0##_type, p1##_type, \
<span class="lineNum">    1603 </span>            :       p2##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(\
<span class="lineNum">    1604 </span>            :       arg_type arg, \
<span class="lineNum">    1605 </span>            :       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
<span class="lineNum">    1606 </span>            :           const
<span class="lineNum">    1607 </span>            : 
<span class="lineNum">    1608 </span>            : #define MATCHER_P4(name, p0, p1, p2, p3, description)\
<span class="lineNum">    1609 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    1610 </span>            :       typename p3##_type&gt;\
<span class="lineNum">    1611 </span>            :   class name##MatcherP4 {\
<span class="lineNum">    1612 </span>            :    public:\
<span class="lineNum">    1613 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    1614 </span>            :     class gmock_Impl : public ::testing::MatcherInterface&lt;arg_type&gt; {\
<span class="lineNum">    1615 </span>            :      public:\
<span class="lineNum">    1616 </span>            :       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
<span class="lineNum">    1617 </span>            :           p3##_type gmock_p3)\
<span class="lineNum">    1618 </span>            :            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3) {}\
<span class="lineNum">    1619 </span>            :       virtual bool MatchAndExplain(\
<span class="lineNum">    1620 </span>            :           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
<span class="lineNum">    1621 </span>            :       virtual void DescribeTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    1622 </span>            :         *gmock_os &lt;&lt; FormatDescription(false);\
<span class="lineNum">    1623 </span>            :       }\
<span class="lineNum">    1624 </span>            :       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    1625 </span>            :         *gmock_os &lt;&lt; FormatDescription(true);\
<span class="lineNum">    1626 </span>            :       }\
<span class="lineNum">    1627 </span>            :       p0##_type p0;\
<span class="lineNum">    1628 </span>            :       p1##_type p1;\
<span class="lineNum">    1629 </span>            :       p2##_type p2;\
<span class="lineNum">    1630 </span>            :       p3##_type p3;\
<span class="lineNum">    1631 </span>            :      private:\
<span class="lineNum">    1632 </span>            :       ::testing::internal::string FormatDescription(bool negation) const {\
<span class="lineNum">    1633 </span>            :         const ::testing::internal::string gmock_description = (description);\
<span class="lineNum">    1634 </span>            :         if (!gmock_description.empty())\
<span class="lineNum">    1635 </span>            :           return gmock_description;\
<span class="lineNum">    1636 </span>            :         return ::testing::internal::FormatMatcherDescription(\
<span class="lineNum">    1637 </span>            :             negation, #name, \
<span class="lineNum">    1638 </span>            :             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
<span class="lineNum">    1639 </span>            :                 ::std::tr1::tuple&lt;p0##_type, p1##_type, p2##_type, \
<span class="lineNum">    1640 </span>            :                     p3##_type&gt;(p0, p1, p2, p3)));\
<span class="lineNum">    1641 </span>            :       }\
<span class="lineNum">    1642 </span>            :       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
<span class="lineNum">    1643 </span>            :     };\
<span class="lineNum">    1644 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    1645 </span>            :     operator ::testing::Matcher&lt;arg_type&gt;() const {\
<span class="lineNum">    1646 </span>            :       return ::testing::Matcher&lt;arg_type&gt;(\
<span class="lineNum">    1647 </span>            :           new gmock_Impl&lt;arg_type&gt;(p0, p1, p2, p3));\
<span class="lineNum">    1648 </span>            :     }\
<span class="lineNum">    1649 </span>            :     name##MatcherP4(p0##_type gmock_p0, p1##_type gmock_p1, \
<span class="lineNum">    1650 </span>            :         p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \
<span class="lineNum">    1651 </span>            :         p2(gmock_p2), p3(gmock_p3) {\
<span class="lineNum">    1652 </span>            :     }\
<span class="lineNum">    1653 </span>            :     p0##_type p0;\
<span class="lineNum">    1654 </span>            :     p1##_type p1;\
<span class="lineNum">    1655 </span>            :     p2##_type p2;\
<span class="lineNum">    1656 </span>            :     p3##_type p3;\
<span class="lineNum">    1657 </span>            :    private:\
<span class="lineNum">    1658 </span>            :     GTEST_DISALLOW_ASSIGN_(name##MatcherP4);\
<span class="lineNum">    1659 </span>            :   };\
<span class="lineNum">    1660 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    1661 </span>            :       typename p3##_type&gt;\
<span class="lineNum">    1662 </span>            :   inline name##MatcherP4&lt;p0##_type, p1##_type, p2##_type, \
<span class="lineNum">    1663 </span>            :       p3##_type&gt; name(p0##_type p0, p1##_type p1, p2##_type p2, \
<span class="lineNum">    1664 </span>            :       p3##_type p3) {\
<span class="lineNum">    1665 </span>            :     return name##MatcherP4&lt;p0##_type, p1##_type, p2##_type, p3##_type&gt;(p0, \
<span class="lineNum">    1666 </span>            :         p1, p2, p3);\
<span class="lineNum">    1667 </span>            :   }\
<span class="lineNum">    1668 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    1669 </span>            :       typename p3##_type&gt;\
<span class="lineNum">    1670 </span>            :   template &lt;typename arg_type&gt;\
<span class="lineNum">    1671 </span>            :   bool name##MatcherP4&lt;p0##_type, p1##_type, p2##_type, \
<span class="lineNum">    1672 </span>            :       p3##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(\
<span class="lineNum">    1673 </span>            :       arg_type arg, \
<span class="lineNum">    1674 </span>            :       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
<span class="lineNum">    1675 </span>            :           const
<span class="lineNum">    1676 </span>            : 
<span class="lineNum">    1677 </span>            : #define MATCHER_P5(name, p0, p1, p2, p3, p4, description)\
<span class="lineNum">    1678 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    1679 </span>            :       typename p3##_type, typename p4##_type&gt;\
<span class="lineNum">    1680 </span>            :   class name##MatcherP5 {\
<span class="lineNum">    1681 </span>            :    public:\
<span class="lineNum">    1682 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    1683 </span>            :     class gmock_Impl : public ::testing::MatcherInterface&lt;arg_type&gt; {\
<span class="lineNum">    1684 </span>            :      public:\
<span class="lineNum">    1685 </span>            :       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
<span class="lineNum">    1686 </span>            :           p3##_type gmock_p3, p4##_type gmock_p4)\
<span class="lineNum">    1687 </span>            :            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
<span class="lineNum">    1688 </span>            :                p4(gmock_p4) {}\
<span class="lineNum">    1689 </span>            :       virtual bool MatchAndExplain(\
<span class="lineNum">    1690 </span>            :           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
<span class="lineNum">    1691 </span>            :       virtual void DescribeTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    1692 </span>            :         *gmock_os &lt;&lt; FormatDescription(false);\
<span class="lineNum">    1693 </span>            :       }\
<span class="lineNum">    1694 </span>            :       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    1695 </span>            :         *gmock_os &lt;&lt; FormatDescription(true);\
<span class="lineNum">    1696 </span>            :       }\
<span class="lineNum">    1697 </span>            :       p0##_type p0;\
<span class="lineNum">    1698 </span>            :       p1##_type p1;\
<span class="lineNum">    1699 </span>            :       p2##_type p2;\
<span class="lineNum">    1700 </span>            :       p3##_type p3;\
<span class="lineNum">    1701 </span>            :       p4##_type p4;\
<span class="lineNum">    1702 </span>            :      private:\
<span class="lineNum">    1703 </span>            :       ::testing::internal::string FormatDescription(bool negation) const {\
<span class="lineNum">    1704 </span>            :         const ::testing::internal::string gmock_description = (description);\
<span class="lineNum">    1705 </span>            :         if (!gmock_description.empty())\
<span class="lineNum">    1706 </span>            :           return gmock_description;\
<span class="lineNum">    1707 </span>            :         return ::testing::internal::FormatMatcherDescription(\
<span class="lineNum">    1708 </span>            :             negation, #name, \
<span class="lineNum">    1709 </span>            :             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
<span class="lineNum">    1710 </span>            :                 ::std::tr1::tuple&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    1711 </span>            :                     p4##_type&gt;(p0, p1, p2, p3, p4)));\
<span class="lineNum">    1712 </span>            :       }\
<span class="lineNum">    1713 </span>            :       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
<span class="lineNum">    1714 </span>            :     };\
<span class="lineNum">    1715 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    1716 </span>            :     operator ::testing::Matcher&lt;arg_type&gt;() const {\
<span class="lineNum">    1717 </span>            :       return ::testing::Matcher&lt;arg_type&gt;(\
<span class="lineNum">    1718 </span>            :           new gmock_Impl&lt;arg_type&gt;(p0, p1, p2, p3, p4));\
<span class="lineNum">    1719 </span>            :     }\
<span class="lineNum">    1720 </span>            :     name##MatcherP5(p0##_type gmock_p0, p1##_type gmock_p1, \
<span class="lineNum">    1721 </span>            :         p2##_type gmock_p2, p3##_type gmock_p3, \
<span class="lineNum">    1722 </span>            :         p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
<span class="lineNum">    1723 </span>            :         p3(gmock_p3), p4(gmock_p4) {\
<span class="lineNum">    1724 </span>            :     }\
<span class="lineNum">    1725 </span>            :     p0##_type p0;\
<span class="lineNum">    1726 </span>            :     p1##_type p1;\
<span class="lineNum">    1727 </span>            :     p2##_type p2;\
<span class="lineNum">    1728 </span>            :     p3##_type p3;\
<span class="lineNum">    1729 </span>            :     p4##_type p4;\
<span class="lineNum">    1730 </span>            :    private:\
<span class="lineNum">    1731 </span>            :     GTEST_DISALLOW_ASSIGN_(name##MatcherP5);\
<span class="lineNum">    1732 </span>            :   };\
<span class="lineNum">    1733 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    1734 </span>            :       typename p3##_type, typename p4##_type&gt;\
<span class="lineNum">    1735 </span>            :   inline name##MatcherP5&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    1736 </span>            :       p4##_type&gt; name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
<span class="lineNum">    1737 </span>            :       p4##_type p4) {\
<span class="lineNum">    1738 </span>            :     return name##MatcherP5&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    1739 </span>            :         p4##_type&gt;(p0, p1, p2, p3, p4);\
<span class="lineNum">    1740 </span>            :   }\
<span class="lineNum">    1741 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    1742 </span>            :       typename p3##_type, typename p4##_type&gt;\
<span class="lineNum">    1743 </span>            :   template &lt;typename arg_type&gt;\
<span class="lineNum">    1744 </span>            :   bool name##MatcherP5&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    1745 </span>            :       p4##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(\
<span class="lineNum">    1746 </span>            :       arg_type arg, \
<span class="lineNum">    1747 </span>            :       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
<span class="lineNum">    1748 </span>            :           const
<span class="lineNum">    1749 </span>            : 
<span class="lineNum">    1750 </span>            : #define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description)\
<span class="lineNum">    1751 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    1752 </span>            :       typename p3##_type, typename p4##_type, typename p5##_type&gt;\
<span class="lineNum">    1753 </span>            :   class name##MatcherP6 {\
<span class="lineNum">    1754 </span>            :    public:\
<span class="lineNum">    1755 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    1756 </span>            :     class gmock_Impl : public ::testing::MatcherInterface&lt;arg_type&gt; {\
<span class="lineNum">    1757 </span>            :      public:\
<span class="lineNum">    1758 </span>            :       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
<span class="lineNum">    1759 </span>            :           p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5)\
<span class="lineNum">    1760 </span>            :            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
<span class="lineNum">    1761 </span>            :                p4(gmock_p4), p5(gmock_p5) {}\
<span class="lineNum">    1762 </span>            :       virtual bool MatchAndExplain(\
<span class="lineNum">    1763 </span>            :           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
<span class="lineNum">    1764 </span>            :       virtual void DescribeTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    1765 </span>            :         *gmock_os &lt;&lt; FormatDescription(false);\
<span class="lineNum">    1766 </span>            :       }\
<span class="lineNum">    1767 </span>            :       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    1768 </span>            :         *gmock_os &lt;&lt; FormatDescription(true);\
<span class="lineNum">    1769 </span>            :       }\
<span class="lineNum">    1770 </span>            :       p0##_type p0;\
<span class="lineNum">    1771 </span>            :       p1##_type p1;\
<span class="lineNum">    1772 </span>            :       p2##_type p2;\
<span class="lineNum">    1773 </span>            :       p3##_type p3;\
<span class="lineNum">    1774 </span>            :       p4##_type p4;\
<span class="lineNum">    1775 </span>            :       p5##_type p5;\
<span class="lineNum">    1776 </span>            :      private:\
<span class="lineNum">    1777 </span>            :       ::testing::internal::string FormatDescription(bool negation) const {\
<span class="lineNum">    1778 </span>            :         const ::testing::internal::string gmock_description = (description);\
<span class="lineNum">    1779 </span>            :         if (!gmock_description.empty())\
<span class="lineNum">    1780 </span>            :           return gmock_description;\
<span class="lineNum">    1781 </span>            :         return ::testing::internal::FormatMatcherDescription(\
<span class="lineNum">    1782 </span>            :             negation, #name, \
<span class="lineNum">    1783 </span>            :             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
<span class="lineNum">    1784 </span>            :                 ::std::tr1::tuple&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    1785 </span>            :                     p4##_type, p5##_type&gt;(p0, p1, p2, p3, p4, p5)));\
<span class="lineNum">    1786 </span>            :       }\
<span class="lineNum">    1787 </span>            :       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
<span class="lineNum">    1788 </span>            :     };\
<span class="lineNum">    1789 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    1790 </span>            :     operator ::testing::Matcher&lt;arg_type&gt;() const {\
<span class="lineNum">    1791 </span>            :       return ::testing::Matcher&lt;arg_type&gt;(\
<span class="lineNum">    1792 </span>            :           new gmock_Impl&lt;arg_type&gt;(p0, p1, p2, p3, p4, p5));\
<span class="lineNum">    1793 </span>            :     }\
<span class="lineNum">    1794 </span>            :     name##MatcherP6(p0##_type gmock_p0, p1##_type gmock_p1, \
<span class="lineNum">    1795 </span>            :         p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
<span class="lineNum">    1796 </span>            :         p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
<span class="lineNum">    1797 </span>            :         p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {\
<span class="lineNum">    1798 </span>            :     }\
<span class="lineNum">    1799 </span>            :     p0##_type p0;\
<span class="lineNum">    1800 </span>            :     p1##_type p1;\
<span class="lineNum">    1801 </span>            :     p2##_type p2;\
<span class="lineNum">    1802 </span>            :     p3##_type p3;\
<span class="lineNum">    1803 </span>            :     p4##_type p4;\
<span class="lineNum">    1804 </span>            :     p5##_type p5;\
<span class="lineNum">    1805 </span>            :    private:\
<span class="lineNum">    1806 </span>            :     GTEST_DISALLOW_ASSIGN_(name##MatcherP6);\
<span class="lineNum">    1807 </span>            :   };\
<span class="lineNum">    1808 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    1809 </span>            :       typename p3##_type, typename p4##_type, typename p5##_type&gt;\
<span class="lineNum">    1810 </span>            :   inline name##MatcherP6&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    1811 </span>            :       p4##_type, p5##_type&gt; name(p0##_type p0, p1##_type p1, p2##_type p2, \
<span class="lineNum">    1812 </span>            :       p3##_type p3, p4##_type p4, p5##_type p5) {\
<span class="lineNum">    1813 </span>            :     return name##MatcherP6&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    1814 </span>            :         p4##_type, p5##_type&gt;(p0, p1, p2, p3, p4, p5);\
<span class="lineNum">    1815 </span>            :   }\
<span class="lineNum">    1816 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    1817 </span>            :       typename p3##_type, typename p4##_type, typename p5##_type&gt;\
<span class="lineNum">    1818 </span>            :   template &lt;typename arg_type&gt;\
<span class="lineNum">    1819 </span>            :   bool name##MatcherP6&lt;p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
<span class="lineNum">    1820 </span>            :       p5##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(\
<span class="lineNum">    1821 </span>            :       arg_type arg, \
<span class="lineNum">    1822 </span>            :       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
<span class="lineNum">    1823 </span>            :           const
<span class="lineNum">    1824 </span>            : 
<span class="lineNum">    1825 </span>            : #define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description)\
<span class="lineNum">    1826 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    1827 </span>            :       typename p3##_type, typename p4##_type, typename p5##_type, \
<span class="lineNum">    1828 </span>            :       typename p6##_type&gt;\
<span class="lineNum">    1829 </span>            :   class name##MatcherP7 {\
<span class="lineNum">    1830 </span>            :    public:\
<span class="lineNum">    1831 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    1832 </span>            :     class gmock_Impl : public ::testing::MatcherInterface&lt;arg_type&gt; {\
<span class="lineNum">    1833 </span>            :      public:\
<span class="lineNum">    1834 </span>            :       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
<span class="lineNum">    1835 </span>            :           p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
<span class="lineNum">    1836 </span>            :           p6##_type gmock_p6)\
<span class="lineNum">    1837 </span>            :            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
<span class="lineNum">    1838 </span>            :                p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\
<span class="lineNum">    1839 </span>            :       virtual bool MatchAndExplain(\
<span class="lineNum">    1840 </span>            :           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
<span class="lineNum">    1841 </span>            :       virtual void DescribeTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    1842 </span>            :         *gmock_os &lt;&lt; FormatDescription(false);\
<span class="lineNum">    1843 </span>            :       }\
<span class="lineNum">    1844 </span>            :       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    1845 </span>            :         *gmock_os &lt;&lt; FormatDescription(true);\
<span class="lineNum">    1846 </span>            :       }\
<span class="lineNum">    1847 </span>            :       p0##_type p0;\
<span class="lineNum">    1848 </span>            :       p1##_type p1;\
<span class="lineNum">    1849 </span>            :       p2##_type p2;\
<span class="lineNum">    1850 </span>            :       p3##_type p3;\
<span class="lineNum">    1851 </span>            :       p4##_type p4;\
<span class="lineNum">    1852 </span>            :       p5##_type p5;\
<span class="lineNum">    1853 </span>            :       p6##_type p6;\
<span class="lineNum">    1854 </span>            :      private:\
<span class="lineNum">    1855 </span>            :       ::testing::internal::string FormatDescription(bool negation) const {\
<span class="lineNum">    1856 </span>            :         const ::testing::internal::string gmock_description = (description);\
<span class="lineNum">    1857 </span>            :         if (!gmock_description.empty())\
<span class="lineNum">    1858 </span>            :           return gmock_description;\
<span class="lineNum">    1859 </span>            :         return ::testing::internal::FormatMatcherDescription(\
<span class="lineNum">    1860 </span>            :             negation, #name, \
<span class="lineNum">    1861 </span>            :             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
<span class="lineNum">    1862 </span>            :                 ::std::tr1::tuple&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    1863 </span>            :                     p4##_type, p5##_type, p6##_type&gt;(p0, p1, p2, p3, p4, p5, \
<span class="lineNum">    1864 </span>            :                     p6)));\
<span class="lineNum">    1865 </span>            :       }\
<span class="lineNum">    1866 </span>            :       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
<span class="lineNum">    1867 </span>            :     };\
<span class="lineNum">    1868 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    1869 </span>            :     operator ::testing::Matcher&lt;arg_type&gt;() const {\
<span class="lineNum">    1870 </span>            :       return ::testing::Matcher&lt;arg_type&gt;(\
<span class="lineNum">    1871 </span>            :           new gmock_Impl&lt;arg_type&gt;(p0, p1, p2, p3, p4, p5, p6));\
<span class="lineNum">    1872 </span>            :     }\
<span class="lineNum">    1873 </span>            :     name##MatcherP7(p0##_type gmock_p0, p1##_type gmock_p1, \
<span class="lineNum">    1874 </span>            :         p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
<span class="lineNum">    1875 </span>            :         p5##_type gmock_p5, p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), \
<span class="lineNum">    1876 </span>            :         p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \
<span class="lineNum">    1877 </span>            :         p6(gmock_p6) {\
<span class="lineNum">    1878 </span>            :     }\
<span class="lineNum">    1879 </span>            :     p0##_type p0;\
<span class="lineNum">    1880 </span>            :     p1##_type p1;\
<span class="lineNum">    1881 </span>            :     p2##_type p2;\
<span class="lineNum">    1882 </span>            :     p3##_type p3;\
<span class="lineNum">    1883 </span>            :     p4##_type p4;\
<span class="lineNum">    1884 </span>            :     p5##_type p5;\
<span class="lineNum">    1885 </span>            :     p6##_type p6;\
<span class="lineNum">    1886 </span>            :    private:\
<span class="lineNum">    1887 </span>            :     GTEST_DISALLOW_ASSIGN_(name##MatcherP7);\
<span class="lineNum">    1888 </span>            :   };\
<span class="lineNum">    1889 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    1890 </span>            :       typename p3##_type, typename p4##_type, typename p5##_type, \
<span class="lineNum">    1891 </span>            :       typename p6##_type&gt;\
<span class="lineNum">    1892 </span>            :   inline name##MatcherP7&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    1893 </span>            :       p4##_type, p5##_type, p6##_type&gt; name(p0##_type p0, p1##_type p1, \
<span class="lineNum">    1894 </span>            :       p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
<span class="lineNum">    1895 </span>            :       p6##_type p6) {\
<span class="lineNum">    1896 </span>            :     return name##MatcherP7&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    1897 </span>            :         p4##_type, p5##_type, p6##_type&gt;(p0, p1, p2, p3, p4, p5, p6);\
<span class="lineNum">    1898 </span>            :   }\
<span class="lineNum">    1899 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    1900 </span>            :       typename p3##_type, typename p4##_type, typename p5##_type, \
<span class="lineNum">    1901 </span>            :       typename p6##_type&gt;\
<span class="lineNum">    1902 </span>            :   template &lt;typename arg_type&gt;\
<span class="lineNum">    1903 </span>            :   bool name##MatcherP7&lt;p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
<span class="lineNum">    1904 </span>            :       p5##_type, p6##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(\
<span class="lineNum">    1905 </span>            :       arg_type arg, \
<span class="lineNum">    1906 </span>            :       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
<span class="lineNum">    1907 </span>            :           const
<span class="lineNum">    1908 </span>            : 
<span class="lineNum">    1909 </span>            : #define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description)\
<span class="lineNum">    1910 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    1911 </span>            :       typename p3##_type, typename p4##_type, typename p5##_type, \
<span class="lineNum">    1912 </span>            :       typename p6##_type, typename p7##_type&gt;\
<span class="lineNum">    1913 </span>            :   class name##MatcherP8 {\
<span class="lineNum">    1914 </span>            :    public:\
<span class="lineNum">    1915 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    1916 </span>            :     class gmock_Impl : public ::testing::MatcherInterface&lt;arg_type&gt; {\
<span class="lineNum">    1917 </span>            :      public:\
<span class="lineNum">    1918 </span>            :       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
<span class="lineNum">    1919 </span>            :           p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
<span class="lineNum">    1920 </span>            :           p6##_type gmock_p6, p7##_type gmock_p7)\
<span class="lineNum">    1921 </span>            :            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
<span class="lineNum">    1922 </span>            :                p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\
<span class="lineNum">    1923 </span>            :       virtual bool MatchAndExplain(\
<span class="lineNum">    1924 </span>            :           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
<span class="lineNum">    1925 </span>            :       virtual void DescribeTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    1926 </span>            :         *gmock_os &lt;&lt; FormatDescription(false);\
<span class="lineNum">    1927 </span>            :       }\
<span class="lineNum">    1928 </span>            :       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    1929 </span>            :         *gmock_os &lt;&lt; FormatDescription(true);\
<span class="lineNum">    1930 </span>            :       }\
<span class="lineNum">    1931 </span>            :       p0##_type p0;\
<span class="lineNum">    1932 </span>            :       p1##_type p1;\
<span class="lineNum">    1933 </span>            :       p2##_type p2;\
<span class="lineNum">    1934 </span>            :       p3##_type p3;\
<span class="lineNum">    1935 </span>            :       p4##_type p4;\
<span class="lineNum">    1936 </span>            :       p5##_type p5;\
<span class="lineNum">    1937 </span>            :       p6##_type p6;\
<span class="lineNum">    1938 </span>            :       p7##_type p7;\
<span class="lineNum">    1939 </span>            :      private:\
<span class="lineNum">    1940 </span>            :       ::testing::internal::string FormatDescription(bool negation) const {\
<span class="lineNum">    1941 </span>            :         const ::testing::internal::string gmock_description = (description);\
<span class="lineNum">    1942 </span>            :         if (!gmock_description.empty())\
<span class="lineNum">    1943 </span>            :           return gmock_description;\
<span class="lineNum">    1944 </span>            :         return ::testing::internal::FormatMatcherDescription(\
<span class="lineNum">    1945 </span>            :             negation, #name, \
<span class="lineNum">    1946 </span>            :             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
<span class="lineNum">    1947 </span>            :                 ::std::tr1::tuple&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    1948 </span>            :                     p4##_type, p5##_type, p6##_type, p7##_type&gt;(p0, p1, p2, \
<span class="lineNum">    1949 </span>            :                     p3, p4, p5, p6, p7)));\
<span class="lineNum">    1950 </span>            :       }\
<span class="lineNum">    1951 </span>            :       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
<span class="lineNum">    1952 </span>            :     };\
<span class="lineNum">    1953 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    1954 </span>            :     operator ::testing::Matcher&lt;arg_type&gt;() const {\
<span class="lineNum">    1955 </span>            :       return ::testing::Matcher&lt;arg_type&gt;(\
<span class="lineNum">    1956 </span>            :           new gmock_Impl&lt;arg_type&gt;(p0, p1, p2, p3, p4, p5, p6, p7));\
<span class="lineNum">    1957 </span>            :     }\
<span class="lineNum">    1958 </span>            :     name##MatcherP8(p0##_type gmock_p0, p1##_type gmock_p1, \
<span class="lineNum">    1959 </span>            :         p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
<span class="lineNum">    1960 </span>            :         p5##_type gmock_p5, p6##_type gmock_p6, \
<span class="lineNum">    1961 </span>            :         p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
<span class="lineNum">    1962 </span>            :         p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
<span class="lineNum">    1963 </span>            :         p7(gmock_p7) {\
<span class="lineNum">    1964 </span>            :     }\
<span class="lineNum">    1965 </span>            :     p0##_type p0;\
<span class="lineNum">    1966 </span>            :     p1##_type p1;\
<span class="lineNum">    1967 </span>            :     p2##_type p2;\
<span class="lineNum">    1968 </span>            :     p3##_type p3;\
<span class="lineNum">    1969 </span>            :     p4##_type p4;\
<span class="lineNum">    1970 </span>            :     p5##_type p5;\
<span class="lineNum">    1971 </span>            :     p6##_type p6;\
<span class="lineNum">    1972 </span>            :     p7##_type p7;\
<span class="lineNum">    1973 </span>            :    private:\
<span class="lineNum">    1974 </span>            :     GTEST_DISALLOW_ASSIGN_(name##MatcherP8);\
<span class="lineNum">    1975 </span>            :   };\
<span class="lineNum">    1976 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    1977 </span>            :       typename p3##_type, typename p4##_type, typename p5##_type, \
<span class="lineNum">    1978 </span>            :       typename p6##_type, typename p7##_type&gt;\
<span class="lineNum">    1979 </span>            :   inline name##MatcherP8&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    1980 </span>            :       p4##_type, p5##_type, p6##_type, p7##_type&gt; name(p0##_type p0, \
<span class="lineNum">    1981 </span>            :       p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
<span class="lineNum">    1982 </span>            :       p6##_type p6, p7##_type p7) {\
<span class="lineNum">    1983 </span>            :     return name##MatcherP8&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    1984 </span>            :         p4##_type, p5##_type, p6##_type, p7##_type&gt;(p0, p1, p2, p3, p4, p5, \
<span class="lineNum">    1985 </span>            :         p6, p7);\
<span class="lineNum">    1986 </span>            :   }\
<span class="lineNum">    1987 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    1988 </span>            :       typename p3##_type, typename p4##_type, typename p5##_type, \
<span class="lineNum">    1989 </span>            :       typename p6##_type, typename p7##_type&gt;\
<span class="lineNum">    1990 </span>            :   template &lt;typename arg_type&gt;\
<span class="lineNum">    1991 </span>            :   bool name##MatcherP8&lt;p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
<span class="lineNum">    1992 </span>            :       p5##_type, p6##_type, \
<span class="lineNum">    1993 </span>            :       p7##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(\
<span class="lineNum">    1994 </span>            :       arg_type arg, \
<span class="lineNum">    1995 </span>            :       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
<span class="lineNum">    1996 </span>            :           const
<span class="lineNum">    1997 </span>            : 
<span class="lineNum">    1998 </span>            : #define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description)\
<span class="lineNum">    1999 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    2000 </span>            :       typename p3##_type, typename p4##_type, typename p5##_type, \
<span class="lineNum">    2001 </span>            :       typename p6##_type, typename p7##_type, typename p8##_type&gt;\
<span class="lineNum">    2002 </span>            :   class name##MatcherP9 {\
<span class="lineNum">    2003 </span>            :    public:\
<span class="lineNum">    2004 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    2005 </span>            :     class gmock_Impl : public ::testing::MatcherInterface&lt;arg_type&gt; {\
<span class="lineNum">    2006 </span>            :      public:\
<span class="lineNum">    2007 </span>            :       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
<span class="lineNum">    2008 </span>            :           p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
<span class="lineNum">    2009 </span>            :           p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8)\
<span class="lineNum">    2010 </span>            :            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
<span class="lineNum">    2011 </span>            :                p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
<span class="lineNum">    2012 </span>            :                p8(gmock_p8) {}\
<span class="lineNum">    2013 </span>            :       virtual bool MatchAndExplain(\
<span class="lineNum">    2014 </span>            :           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
<span class="lineNum">    2015 </span>            :       virtual void DescribeTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    2016 </span>            :         *gmock_os &lt;&lt; FormatDescription(false);\
<span class="lineNum">    2017 </span>            :       }\
<span class="lineNum">    2018 </span>            :       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    2019 </span>            :         *gmock_os &lt;&lt; FormatDescription(true);\
<span class="lineNum">    2020 </span>            :       }\
<span class="lineNum">    2021 </span>            :       p0##_type p0;\
<span class="lineNum">    2022 </span>            :       p1##_type p1;\
<span class="lineNum">    2023 </span>            :       p2##_type p2;\
<span class="lineNum">    2024 </span>            :       p3##_type p3;\
<span class="lineNum">    2025 </span>            :       p4##_type p4;\
<span class="lineNum">    2026 </span>            :       p5##_type p5;\
<span class="lineNum">    2027 </span>            :       p6##_type p6;\
<span class="lineNum">    2028 </span>            :       p7##_type p7;\
<span class="lineNum">    2029 </span>            :       p8##_type p8;\
<span class="lineNum">    2030 </span>            :      private:\
<span class="lineNum">    2031 </span>            :       ::testing::internal::string FormatDescription(bool negation) const {\
<span class="lineNum">    2032 </span>            :         const ::testing::internal::string gmock_description = (description);\
<span class="lineNum">    2033 </span>            :         if (!gmock_description.empty())\
<span class="lineNum">    2034 </span>            :           return gmock_description;\
<span class="lineNum">    2035 </span>            :         return ::testing::internal::FormatMatcherDescription(\
<span class="lineNum">    2036 </span>            :             negation, #name, \
<span class="lineNum">    2037 </span>            :             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
<span class="lineNum">    2038 </span>            :                 ::std::tr1::tuple&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    2039 </span>            :                     p4##_type, p5##_type, p6##_type, p7##_type, \
<span class="lineNum">    2040 </span>            :                     p8##_type&gt;(p0, p1, p2, p3, p4, p5, p6, p7, p8)));\
<span class="lineNum">    2041 </span>            :       }\
<span class="lineNum">    2042 </span>            :       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
<span class="lineNum">    2043 </span>            :     };\
<span class="lineNum">    2044 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    2045 </span>            :     operator ::testing::Matcher&lt;arg_type&gt;() const {\
<span class="lineNum">    2046 </span>            :       return ::testing::Matcher&lt;arg_type&gt;(\
<span class="lineNum">    2047 </span>            :           new gmock_Impl&lt;arg_type&gt;(p0, p1, p2, p3, p4, p5, p6, p7, p8));\
<span class="lineNum">    2048 </span>            :     }\
<span class="lineNum">    2049 </span>            :     name##MatcherP9(p0##_type gmock_p0, p1##_type gmock_p1, \
<span class="lineNum">    2050 </span>            :         p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
<span class="lineNum">    2051 </span>            :         p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
<span class="lineNum">    2052 </span>            :         p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
<span class="lineNum">    2053 </span>            :         p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
<span class="lineNum">    2054 </span>            :         p8(gmock_p8) {\
<span class="lineNum">    2055 </span>            :     }\
<span class="lineNum">    2056 </span>            :     p0##_type p0;\
<span class="lineNum">    2057 </span>            :     p1##_type p1;\
<span class="lineNum">    2058 </span>            :     p2##_type p2;\
<span class="lineNum">    2059 </span>            :     p3##_type p3;\
<span class="lineNum">    2060 </span>            :     p4##_type p4;\
<span class="lineNum">    2061 </span>            :     p5##_type p5;\
<span class="lineNum">    2062 </span>            :     p6##_type p6;\
<span class="lineNum">    2063 </span>            :     p7##_type p7;\
<span class="lineNum">    2064 </span>            :     p8##_type p8;\
<span class="lineNum">    2065 </span>            :    private:\
<span class="lineNum">    2066 </span>            :     GTEST_DISALLOW_ASSIGN_(name##MatcherP9);\
<span class="lineNum">    2067 </span>            :   };\
<span class="lineNum">    2068 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    2069 </span>            :       typename p3##_type, typename p4##_type, typename p5##_type, \
<span class="lineNum">    2070 </span>            :       typename p6##_type, typename p7##_type, typename p8##_type&gt;\
<span class="lineNum">    2071 </span>            :   inline name##MatcherP9&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    2072 </span>            :       p4##_type, p5##_type, p6##_type, p7##_type, \
<span class="lineNum">    2073 </span>            :       p8##_type&gt; name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
<span class="lineNum">    2074 </span>            :       p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \
<span class="lineNum">    2075 </span>            :       p8##_type p8) {\
<span class="lineNum">    2076 </span>            :     return name##MatcherP9&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    2077 </span>            :         p4##_type, p5##_type, p6##_type, p7##_type, p8##_type&gt;(p0, p1, p2, \
<span class="lineNum">    2078 </span>            :         p3, p4, p5, p6, p7, p8);\
<span class="lineNum">    2079 </span>            :   }\
<span class="lineNum">    2080 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    2081 </span>            :       typename p3##_type, typename p4##_type, typename p5##_type, \
<span class="lineNum">    2082 </span>            :       typename p6##_type, typename p7##_type, typename p8##_type&gt;\
<span class="lineNum">    2083 </span>            :   template &lt;typename arg_type&gt;\
<span class="lineNum">    2084 </span>            :   bool name##MatcherP9&lt;p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
<span class="lineNum">    2085 </span>            :       p5##_type, p6##_type, p7##_type, \
<span class="lineNum">    2086 </span>            :       p8##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(\
<span class="lineNum">    2087 </span>            :       arg_type arg, \
<span class="lineNum">    2088 </span>            :       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
<span class="lineNum">    2089 </span>            :           const
<span class="lineNum">    2090 </span>            : 
<span class="lineNum">    2091 </span>            : #define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description)\
<span class="lineNum">    2092 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    2093 </span>            :       typename p3##_type, typename p4##_type, typename p5##_type, \
<span class="lineNum">    2094 </span>            :       typename p6##_type, typename p7##_type, typename p8##_type, \
<span class="lineNum">    2095 </span>            :       typename p9##_type&gt;\
<span class="lineNum">    2096 </span>            :   class name##MatcherP10 {\
<span class="lineNum">    2097 </span>            :    public:\
<span class="lineNum">    2098 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    2099 </span>            :     class gmock_Impl : public ::testing::MatcherInterface&lt;arg_type&gt; {\
<span class="lineNum">    2100 </span>            :      public:\
<span class="lineNum">    2101 </span>            :       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
<span class="lineNum">    2102 </span>            :           p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
<span class="lineNum">    2103 </span>            :           p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
<span class="lineNum">    2104 </span>            :           p9##_type gmock_p9)\
<span class="lineNum">    2105 </span>            :            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
<span class="lineNum">    2106 </span>            :                p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
<span class="lineNum">    2107 </span>            :                p8(gmock_p8), p9(gmock_p9) {}\
<span class="lineNum">    2108 </span>            :       virtual bool MatchAndExplain(\
<span class="lineNum">    2109 </span>            :           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
<span class="lineNum">    2110 </span>            :       virtual void DescribeTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    2111 </span>            :         *gmock_os &lt;&lt; FormatDescription(false);\
<span class="lineNum">    2112 </span>            :       }\
<span class="lineNum">    2113 </span>            :       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
<span class="lineNum">    2114 </span>            :         *gmock_os &lt;&lt; FormatDescription(true);\
<span class="lineNum">    2115 </span>            :       }\
<span class="lineNum">    2116 </span>            :       p0##_type p0;\
<span class="lineNum">    2117 </span>            :       p1##_type p1;\
<span class="lineNum">    2118 </span>            :       p2##_type p2;\
<span class="lineNum">    2119 </span>            :       p3##_type p3;\
<span class="lineNum">    2120 </span>            :       p4##_type p4;\
<span class="lineNum">    2121 </span>            :       p5##_type p5;\
<span class="lineNum">    2122 </span>            :       p6##_type p6;\
<span class="lineNum">    2123 </span>            :       p7##_type p7;\
<span class="lineNum">    2124 </span>            :       p8##_type p8;\
<span class="lineNum">    2125 </span>            :       p9##_type p9;\
<span class="lineNum">    2126 </span>            :      private:\
<span class="lineNum">    2127 </span>            :       ::testing::internal::string FormatDescription(bool negation) const {\
<span class="lineNum">    2128 </span>            :         const ::testing::internal::string gmock_description = (description);\
<span class="lineNum">    2129 </span>            :         if (!gmock_description.empty())\
<span class="lineNum">    2130 </span>            :           return gmock_description;\
<span class="lineNum">    2131 </span>            :         return ::testing::internal::FormatMatcherDescription(\
<span class="lineNum">    2132 </span>            :             negation, #name, \
<span class="lineNum">    2133 </span>            :             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
<span class="lineNum">    2134 </span>            :                 ::std::tr1::tuple&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    2135 </span>            :                     p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
<span class="lineNum">    2136 </span>            :                     p9##_type&gt;(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)));\
<span class="lineNum">    2137 </span>            :       }\
<span class="lineNum">    2138 </span>            :       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
<span class="lineNum">    2139 </span>            :     };\
<span class="lineNum">    2140 </span>            :     template &lt;typename arg_type&gt;\
<span class="lineNum">    2141 </span>            :     operator ::testing::Matcher&lt;arg_type&gt;() const {\
<span class="lineNum">    2142 </span>            :       return ::testing::Matcher&lt;arg_type&gt;(\
<span class="lineNum">    2143 </span>            :           new gmock_Impl&lt;arg_type&gt;(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9));\
<span class="lineNum">    2144 </span>            :     }\
<span class="lineNum">    2145 </span>            :     name##MatcherP10(p0##_type gmock_p0, p1##_type gmock_p1, \
<span class="lineNum">    2146 </span>            :         p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
<span class="lineNum">    2147 </span>            :         p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
<span class="lineNum">    2148 </span>            :         p8##_type gmock_p8, p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), \
<span class="lineNum">    2149 </span>            :         p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
<span class="lineNum">    2150 </span>            :         p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {\
<span class="lineNum">    2151 </span>            :     }\
<span class="lineNum">    2152 </span>            :     p0##_type p0;\
<span class="lineNum">    2153 </span>            :     p1##_type p1;\
<span class="lineNum">    2154 </span>            :     p2##_type p2;\
<span class="lineNum">    2155 </span>            :     p3##_type p3;\
<span class="lineNum">    2156 </span>            :     p4##_type p4;\
<span class="lineNum">    2157 </span>            :     p5##_type p5;\
<span class="lineNum">    2158 </span>            :     p6##_type p6;\
<span class="lineNum">    2159 </span>            :     p7##_type p7;\
<span class="lineNum">    2160 </span>            :     p8##_type p8;\
<span class="lineNum">    2161 </span>            :     p9##_type p9;\
<span class="lineNum">    2162 </span>            :    private:\
<span class="lineNum">    2163 </span>            :     GTEST_DISALLOW_ASSIGN_(name##MatcherP10);\
<span class="lineNum">    2164 </span>            :   };\
<span class="lineNum">    2165 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    2166 </span>            :       typename p3##_type, typename p4##_type, typename p5##_type, \
<span class="lineNum">    2167 </span>            :       typename p6##_type, typename p7##_type, typename p8##_type, \
<span class="lineNum">    2168 </span>            :       typename p9##_type&gt;\
<span class="lineNum">    2169 </span>            :   inline name##MatcherP10&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    2170 </span>            :       p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
<span class="lineNum">    2171 </span>            :       p9##_type&gt; name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
<span class="lineNum">    2172 </span>            :       p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
<span class="lineNum">    2173 </span>            :       p9##_type p9) {\
<span class="lineNum">    2174 </span>            :     return name##MatcherP10&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    2175 </span>            :         p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type&gt;(p0, \
<span class="lineNum">    2176 </span>            :         p1, p2, p3, p4, p5, p6, p7, p8, p9);\
<span class="lineNum">    2177 </span>            :   }\
<span class="lineNum">    2178 </span>            :   template &lt;typename p0##_type, typename p1##_type, typename p2##_type, \
<span class="lineNum">    2179 </span>            :       typename p3##_type, typename p4##_type, typename p5##_type, \
<span class="lineNum">    2180 </span>            :       typename p6##_type, typename p7##_type, typename p8##_type, \
<span class="lineNum">    2181 </span>            :       typename p9##_type&gt;\
<span class="lineNum">    2182 </span>            :   template &lt;typename arg_type&gt;\
<span class="lineNum">    2183 </span>            :   bool name##MatcherP10&lt;p0##_type, p1##_type, p2##_type, p3##_type, \
<span class="lineNum">    2184 </span>            :       p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
<span class="lineNum">    2185 </span>            :       p9##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(\
<span class="lineNum">    2186 </span>            :       arg_type arg, \
<span class="lineNum">    2187 </span>            :       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
<span class="lineNum">    2188 </span>            :           const
<span class="lineNum">    2189 </span>            : 
<span class="lineNum">    2190 </span>            : #endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
</pre>
      </td>
    </tr>
  </table>
  <br>

  <table width="100%" border=0 cellspacing=0 cellpadding=0>
    <tr><td class="ruler"><img src="../../../../glass.png" width=3 height=3 alt=""></td></tr>
    <tr><td class="versionInfo">Generated by: <a href="http://ltp.sourceforge.net/coverage/lcov.php" target="_parent">LCOV version 1.11</a></td></tr>
  </table>
  <br>

</body>
</html>
